Merge pull request #198 from RocketChat/fix/un-realm-app-the-app

Un-Realm-app the app

app/build.gradle

 apply plugin: 'com.android.application'
 apply plugin: 'me.tatarka.retrolambda'
-apply plugin: 'realm-android'
 apply plugin: 'com.jakewharton.hugo'
 apply plugin: 'com.github.triplet.play'
 apply from: '../config/quality/quality.gradle'
@@ -85,8 +84,9 @@ play {
 dependencies {
     compile project(':log-wrapper')
     compile project(':android-ddp')
+    compile project(':rocket-chat-core')
     compile project(':rocket-chat-android-widgets')
-    compile project(':realm-helpers')
+    compile project(':persistence-realm')
     compile rootProject.ext.supportAppCompat
     compile rootProject.ext.supportDesign
 

app/src/main/java/chat/rocket/android/BackgroundLooper.java

+package chat.rocket.android;
+
+
+import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.Process;
+
+public class BackgroundLooper {
+
+  private static HandlerThread handlerThread;
+
+  public static Looper get() {
+    if (handlerThread == null) {
+      handlerThread =
+          new HandlerThread("BackgroundHandlerThread", Process.THREAD_PRIORITY_BACKGROUND);
+      handlerThread.start();
+    }
+
+    return handlerThread.getLooper();
+  }
+}

app/src/main/java/chat/rocket/android/RocketChatApplication.java

@@ -3,16 +3,15 @@ package chat.rocket.android;
 import android.support.multidex.MultiDexApplication;
 import com.facebook.stetho.Stetho;
 import com.uphyca.stetho_realm.RealmInspectorModulesProvider;
-import io.realm.Realm;
-import io.realm.RealmConfiguration;
 
 import java.util.List;
 import chat.rocket.android.helper.OkHttpHelper;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.persistence.realm.RealmStore;
 import chat.rocket.android.service.ConnectivityManager;
-import chat.rocket.android.service.ServerInfo;
+import chat.rocket.core.models.ServerInfo;
 import chat.rocket.android.widget.RocketChatWidgets;
 import chat.rocket.android.wrappers.InstabugWrapper;
+import chat.rocket.persistence.realm.RocketChatPersistenceRealm;
 
 /**
  * Customized Application-class for Rocket.Chat
@@ -22,13 +21,11 @@ public class RocketChatApplication extends MultiDexApplication {
   public void onCreate() {
     super.onCreate();
 
-    Realm.init(this);
-    Realm.setDefaultConfiguration(
-        new RealmConfiguration.Builder().deleteRealmIfMigrationNeeded().build());
+    RocketChatPersistenceRealm.init(this);
 
     List<ServerInfo> serverInfoList = ConnectivityManager.getInstance(this).getServerList();
     for (ServerInfo serverInfo : serverInfoList) {
-      RealmStore.put(serverInfo.hostname);
+      RealmStore.put(serverInfo.getHostname());
     }
 
     Stetho.initialize(Stetho.newInitializerBuilder(this)

app/src/main/java/chat/rocket/android/activity/AbstractAuthedActivity.java

@@ -8,12 +8,12 @@ import android.support.annotation.Nullable;
 import java.util.List;
 import chat.rocket.android.LaunchUtil;
 import chat.rocket.android.RocketChatCache;
-import chat.rocket.android.model.ddp.RoomSubscription;
+import chat.rocket.persistence.realm.models.ddp.RealmRoom;
 import chat.rocket.android.push.PushConstants;
 import chat.rocket.android.push.PushNotificationHandler;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.persistence.realm.RealmStore;
 import chat.rocket.android.service.ConnectivityManager;
-import chat.rocket.android.service.ServerInfo;
+import chat.rocket.core.models.ServerInfo;
 import icepick.State;
 
 abstract class AbstractAuthedActivity extends AbstractFragmentActivity {
@@ -107,7 +107,7 @@ abstract class AbstractAuthedActivity extends AbstractFragmentActivity {
     // just connect to the first available
     final ServerInfo serverInfo = serverInfoList.get(0);
     prefs.edit()
-        .putString(RocketChatCache.KEY_SELECTED_SERVER_HOSTNAME, serverInfo.hostname)
+        .putString(RocketChatCache.KEY_SELECTED_SERVER_HOSTNAME, serverInfo.getHostname())
         .remove(RocketChatCache.KEY_SELECTED_ROOM_ID)
         .apply();
   }
@@ -130,8 +130,8 @@ abstract class AbstractAuthedActivity extends AbstractFragmentActivity {
       return false;
     }
 
-    RoomSubscription room = RealmStore.get(hostname).executeTransactionForRead(realm ->
-        realm.where(RoomSubscription.class).equalTo(RoomSubscription.ROOM_ID, roomId).findFirst());
+    RealmRoom room = RealmStore.get(hostname).executeTransactionForRead(realm ->
+        realm.where(RealmRoom.class).equalTo(RealmRoom.ROOM_ID, roomId).findFirst());
     if (room == null) {
       prefs.edit()
           .remove(RocketChatCache.KEY_SELECTED_ROOM_ID)

app/src/main/java/chat/rocket/android/activity/LoginActivity.java

@@ -8,20 +8,17 @@ import android.support.v4.app.Fragment;
 import chat.rocket.android.R;
 import chat.rocket.android.fragment.server_config.LoginFragment;
 import chat.rocket.android.fragment.server_config.RetryLoginFragment;
-import chat.rocket.android.helper.TextUtils;
-import chat.rocket.android.model.internal.Session;
-import chat.rocket.android.realm_helper.RealmObjectObserver;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.core.interactors.SessionInteractor;
 import chat.rocket.android.service.ConnectivityManager;
+import chat.rocket.persistence.realm.repositories.RealmSessionRepository;
 
 /**
  * Activity for Login, Sign-up, and Retry connecting...
  */
-public class LoginActivity extends AbstractFragmentActivity {
+public class LoginActivity extends AbstractFragmentActivity implements LoginContract.View {
   public static final String KEY_HOSTNAME = "hostname";
 
-  private String hostname;
-  private RealmObjectObserver<Session> sessionObserver;
+  private LoginContract.Presenter presenter;
 
   @Override
   protected int getLayoutContainerForFragment() {
@@ -32,69 +29,38 @@ public class LoginActivity extends AbstractFragmentActivity {
   protected void onCreate(@Nullable Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
 
+    String hostname = null;
     Intent intent = getIntent();
-    if (intent == null || intent.getExtras() == null) {
-      finish();
-      return;
+    if (intent != null && intent.getExtras() != null) {
+      hostname = intent.getStringExtra(KEY_HOSTNAME);
     }
 
-    hostname = intent.getStringExtra(KEY_HOSTNAME);
-    if (TextUtils.isEmpty(hostname)) {
-      finish();
-      return;
-    }
-
-    sessionObserver = RealmStore.get(hostname)
-        .createObjectObserver(Session::queryDefaultSession)
-        .setOnUpdateListener(this::onRenderServerConfigSession);
-
-    setContentView(R.layout.simple_screen);
-    showFragment(new LoginFragment());
+    presenter = new LoginPresenter(
+        hostname,
+        new SessionInteractor(new RealmSessionRepository(hostname)),
+        ConnectivityManager.getInstance(getApplicationContext())
+    );
   }
 
   @Override
   protected void onResume() {
     super.onResume();
-    ConnectivityManager.getInstance(getApplicationContext()).keepAliveServer();
-    sessionObserver.sub();
+    presenter.bindView(this);
   }
 
   @Override
   protected void onDestroy() {
-    sessionObserver.unsub();
+    presenter.release();
     super.onDestroy();
   }
 
-  private void onRenderServerConfigSession(Session session) {
-    if (session == null) {
-      return;
-    }
-
-    final String token = session.getToken();
-    if (!TextUtils.isEmpty(token)) {
-      if (TextUtils.isEmpty(session.getError())) {
-        finish();
-        overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out);
-      } else {
-        showFragment(new RetryLoginFragment());
-      }
-      return;
-    }
-  }
-
-  @Override
-  protected void showFragment(Fragment fragment) {
-    injectHostnameArgTo(fragment);
+  private void showFragment(Fragment fragment, String hostname) {
+    setContentView(R.layout.simple_screen);
+    injectHostnameArgTo(fragment, hostname);
     super.showFragment(fragment);
   }
 
-  @Override
-  protected void showFragmentWithBackStack(Fragment fragment) {
-    injectHostnameArgTo(fragment);
-    super.showFragmentWithBackStack(fragment);
-  }
-
-  private void injectHostnameArgTo(Fragment fragment) {
+  private void injectHostnameArgTo(Fragment fragment, String hostname) {
     Bundle args = fragment.getArguments();
     if (args == null) {
       args = new Bundle();
@@ -107,4 +73,20 @@ public class LoginActivity extends AbstractFragmentActivity {
   protected void onBackPressedNotHandled() {
     moveTaskToBack(true);
   }
+
+  @Override
+  public void showLogin(String hostname) {
+    showFragment(new LoginFragment(), hostname);
+  }
+
+  @Override
+  public void showRetryLogin(String hostname) {
+    showFragment(new RetryLoginFragment(), hostname);
+  }
+
+  @Override
+  public void closeView() {
+    finish();
+    overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out);
+  }
 }

app/src/main/java/chat/rocket/android/activity/LoginContract.java

+package chat.rocket.android.activity;
+
+import chat.rocket.android.shared.BaseContract;
+
+public interface LoginContract {
+
+  interface View extends BaseContract.View {
+    void showLogin(String hostname);
+
+    void showRetryLogin(String hostname);
+
+    void closeView();
+  }
+
+  interface Presenter extends BaseContract.Presenter<View> {
+  }
+}

app/src/main/java/chat/rocket/android/activity/LoginPresenter.java

+package chat.rocket.android.activity;
+
+import android.support.annotation.NonNull;
+
+import chat.rocket.android.BackgroundLooper;
+import chat.rocket.android.service.ConnectivityManagerApi;
+import chat.rocket.android.shared.BasePresenter;
+import chat.rocket.core.interactors.SessionInteractor;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+
+public class LoginPresenter extends BasePresenter<LoginContract.View>
+    implements LoginContract.Presenter {
+
+  private final String hostname;
+  private final SessionInteractor sessionInteractor;
+  private final ConnectivityManagerApi connectivityManagerApi;
+
+  public LoginPresenter(String hostname,
+                        SessionInteractor sessionInteractor,
+                        ConnectivityManagerApi connectivityManagerApi) {
+    this.hostname = hostname;
+    this.sessionInteractor = sessionInteractor;
+    this.connectivityManagerApi = connectivityManagerApi;
+  }
+
+  @Override
+  public void bindView(@NonNull LoginContract.View view) {
+    super.bindView(view);
+
+    connectivityManagerApi.keepAliveServer();
+
+    if (hostname == null || hostname.length() == 0) {
+      view.closeView();
+      return;
+    }
+
+    loadSessionState();
+  }
+
+  private void loadSessionState() {
+    final Subscription subscription = sessionInteractor.getSessionState()
+        .distinctUntilChanged()
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(state -> {
+          switch (state) {
+            case UNAVAILABLE:
+              view.showLogin(hostname);
+              break;
+            case INVALID:
+              view.showRetryLogin(hostname);
+              break;
+            case VALID:
+              view.closeView();
+          }
+        });
+
+    addSubscription(subscription);
+  }
+}

app/src/main/java/chat/rocket/android/activity/MainActivity.java

@@ -8,7 +8,6 @@ import android.support.v7.graphics.drawable.DrawerArrowDrawable;
 import android.support.v7.widget.Toolbar;
 import android.view.View;
 
-import java.util.List;
 import chat.rocket.android.LaunchUtil;
 import chat.rocket.android.R;
 import chat.rocket.android.api.MethodCallHelper;
@@ -16,28 +15,26 @@ import chat.rocket.android.fragment.chatroom.HomeFragment;
 import chat.rocket.android.fragment.chatroom.RoomFragment;
 import chat.rocket.android.fragment.sidebar.SidebarMainFragment;
 import chat.rocket.android.helper.LogcatIfError;
-import chat.rocket.android.helper.TextUtils;
-import chat.rocket.android.model.ddp.RoomSubscription;
-import chat.rocket.android.model.ddp.User;
-import chat.rocket.android.model.internal.Session;
-import chat.rocket.android.realm_helper.RealmHelper;
-import chat.rocket.android.realm_helper.RealmListObserver;
-import chat.rocket.android.realm_helper.RealmObjectObserver;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.core.interactors.CanCreateRoomInteractor;
+import chat.rocket.core.interactors.RoomInteractor;
+import chat.rocket.core.interactors.SessionInteractor;
+import chat.rocket.core.models.User;
 import chat.rocket.android.service.ConnectivityManager;
 import chat.rocket.android.widget.RoomToolbar;
+import chat.rocket.persistence.realm.repositories.RealmRoomRepository;
+import chat.rocket.persistence.realm.repositories.RealmSessionRepository;
+import chat.rocket.persistence.realm.repositories.RealmUserRepository;
 import hugo.weaving.DebugLog;
 
 /**
  * Entry-point for Rocket.Chat.Android application.
  */
-public class MainActivity extends AbstractAuthedActivity {
+public class MainActivity extends AbstractAuthedActivity implements MainContract.View {
 
-  private RealmObjectObserver<Session> sessionObserver;
-  private RealmListObserver<RoomSubscription> unreadRoomSubscriptionObserver;
-  private boolean isForeground;
   private StatusTicker statusTicker;
 
+  private MainContract.Presenter presenter;
+
   @Override
   protected int getLayoutContainerForFragment() {
     return R.id.activity_main_container;
@@ -68,13 +65,19 @@ public class MainActivity extends AbstractAuthedActivity {
 
   @Override
   protected void onResume() {
-    isForeground = true;
     super.onResume();
+
+    if (presenter != null) {
+      presenter.bindView(this);
+    }
   }
 
   @Override
   protected void onPause() {
-    isForeground = false;
+    if (presenter != null) {
+      presenter.release();
+    }
+
     super.onPause();
   }
 
@@ -162,127 +165,92 @@ public class MainActivity extends AbstractAuthedActivity {
   @Override
   protected void onHostnameUpdated() {
     super.onHostnameUpdated();
-    updateSessionObserver();
-    updateUnreadRoomSubscriptionObserver();
-    updateSidebarMainFragment();
-  }
 
-  private void updateSessionObserver() {
-    if (sessionObserver != null) {
-      sessionObserver.unsub();
-      sessionObserver = null;
+    if (presenter != null) {
+      presenter.release();
     }
 
-    if (hostname == null) {
-      return;
-    }
+    RoomInteractor roomInteractor = new RoomInteractor(new RealmRoomRepository(hostname));
 
-    RealmHelper realmHelper = RealmStore.get(hostname);
-    if (realmHelper == null) {
-      return;
-    }
+    CanCreateRoomInteractor createRoomInteractor = new CanCreateRoomInteractor(
+        new RealmUserRepository(hostname),
+        new SessionInteractor(new RealmSessionRepository(hostname))
+    );
+
+    SessionInteractor sessionInteractor = new SessionInteractor(
+        new RealmSessionRepository(hostname)
+    );
+
+    presenter = new MainPresenter(
+        roomInteractor,
+        createRoomInteractor,
+        sessionInteractor
+    );
 
-    sessionObserver = realmHelper
-        .createObjectObserver(realm ->
-            Session.queryDefaultSession(realm)
-                .isNotNull(Session.TOKEN))
-        .setOnUpdateListener(this::onSessionChanged);
-    sessionObserver.sub();
+    updateSidebarMainFragment();
   }
 
-  private void onSessionChanged(@Nullable Session session) {
-    if (session == null) {
-      if (isForeground) {
-        LaunchUtil.showLoginActivity(this, hostname);
-      }
-      statusTicker.updateStatus(StatusTicker.STATUS_DISMISS, null);
-    } else if (!TextUtils.isEmpty(session.getError())) {
-      statusTicker.updateStatus(StatusTicker.STATUS_CONNECTION_ERROR,
-          Snackbar.make(findViewById(getLayoutContainerForFragment()),
-              R.string.fragment_retry_login_error_title, Snackbar.LENGTH_INDEFINITE)
-              .setAction(R.string.fragment_retry_login_retry_title, view ->
-                  Session.retryLogin(RealmStore.get(hostname))));
-    } else if (!session.isTokenVerified()) {
-      statusTicker.updateStatus(StatusTicker.STATUS_TOKEN_LOGIN,
-          Snackbar.make(findViewById(getLayoutContainerForFragment()),
-              R.string.server_config_activity_authenticating, Snackbar.LENGTH_INDEFINITE));
-    } else {
-      statusTicker.updateStatus(StatusTicker.STATUS_DISMISS, null);
-    }
+  private void updateSidebarMainFragment() {
+    getSupportFragmentManager().beginTransaction()
+        .replace(R.id.sidebar_fragment_container, SidebarMainFragment.create(hostname))
+        .commit();
   }
 
-  private void updateUnreadRoomSubscriptionObserver() {
-    if (unreadRoomSubscriptionObserver != null) {
-      unreadRoomSubscriptionObserver.unsub();
-      unreadRoomSubscriptionObserver = null;
-    }
+  @Override
+  protected void onRoomIdUpdated() {
+    super.onRoomIdUpdated();
+    presenter.onOpenRoom(hostname, roomId);
+  }
 
-    if (hostname == null) {
-      return;
-    }
+  @Override
+  protected boolean onBackPress() {
+    return closeSidebarIfNeeded() || super.onBackPress();
+  }
 
-    RealmHelper realmHelper = RealmStore.get(hostname);
-    if (realmHelper == null) {
-      return;
-    }
+  @Override
+  public void showHome() {
+    showFragment(new HomeFragment());
+  }
 
-    unreadRoomSubscriptionObserver = realmHelper
-        .createListObserver(realm ->
-            realm.where(RoomSubscription.class)
-                .equalTo(RoomSubscription.ALERT, true)
-                .equalTo(RoomSubscription.OPEN, true)
-                .findAll())
-        .setOnUpdateListener(this::updateRoomToolbarUnreadCount);
-    unreadRoomSubscriptionObserver.sub();
+  @Override
+  public void showRoom(String hostname, String roomId) {
+    showFragment(RoomFragment.create(hostname, roomId));
+    closeSidebarIfNeeded();
   }
 
-  private void updateRoomToolbarUnreadCount(List<RoomSubscription> unreadRooms) {
+  @Override
+  public void showUnreadCount(int roomsCount, int mentionsCount) {
     RoomToolbar toolbar = (RoomToolbar) findViewById(R.id.activity_main_toolbar);
     if (toolbar != null) {
-      //ref: Rocket.Chat:client/startup/unread.js
-      final int numUnreadChannels = unreadRooms.size();
-      int numMentionsSum = 0;
-      for (RoomSubscription room : unreadRooms) {
-        numMentionsSum += room.getUnread();
-      }
-      toolbar.setUnreadBudge(numUnreadChannels, numMentionsSum);
+      toolbar.setUnreadBudge(roomsCount, mentionsCount);
     }
   }
 
-  private void updateSidebarMainFragment() {
-    getSupportFragmentManager().beginTransaction()
-        .replace(R.id.sidebar_fragment_container, SidebarMainFragment.create(hostname))
-        .commit();
+  @Override
+  public void showLoginScreen() {
+    LaunchUtil.showLoginActivity(this, hostname);
+    statusTicker.updateStatus(StatusTicker.STATUS_DISMISS, null);
   }
 
   @Override
-  protected void onRoomIdUpdated() {
-    super.onRoomIdUpdated();
-
-    if (roomId != null && RoomFragment.canCreate(RealmStore.get(hostname))) {
-      showFragment(RoomFragment.create(hostname, roomId));
-      closeSidebarIfNeeded();
-    } else {
-      showFragment(new HomeFragment());
-    }
+  public void showConnectionError() {
+    statusTicker.updateStatus(StatusTicker.STATUS_CONNECTION_ERROR,
+        Snackbar.make(findViewById(getLayoutContainerForFragment()),
+            R.string.fragment_retry_login_error_title, Snackbar.LENGTH_INDEFINITE)
+            .setAction(R.string.fragment_retry_login_retry_title, view ->
+                presenter.onRetryLogin()));
   }
 
   @Override
-  protected void onDestroy() {
-    if (sessionObserver != null) {
-      sessionObserver.unsub();
-      sessionObserver = null;
-    }
-    if (unreadRoomSubscriptionObserver != null) {
-      unreadRoomSubscriptionObserver.unsub();
-      unreadRoomSubscriptionObserver = null;
-    }
-    super.onDestroy();
+  public void showConnecting() {
+    statusTicker.updateStatus(StatusTicker.STATUS_TOKEN_LOGIN,
+        Snackbar.make(findViewById(getLayoutContainerForFragment()),
+            R.string.server_config_activity_authenticating, Snackbar.LENGTH_INDEFINITE));
   }
 
   @Override
-  protected boolean onBackPress() {
-    return closeSidebarIfNeeded() || super.onBackPress();
+  public void showConnectionOk() {
+    statusTicker.updateStatus(StatusTicker.STATUS_DISMISS, null);
   }
 
   //TODO: consider this class to define in layouthelper for more complicated operation.

app/src/main/java/chat/rocket/android/activity/MainContract.java

+package chat.rocket.android.activity;
+
+import chat.rocket.android.shared.BaseContract;
+
+public interface MainContract {
+
+  interface View extends BaseContract.View {
+
+    void showHome();
+
+    void showRoom(String hostname, String roomId);
+
+    void showUnreadCount(int roomsCount, int mentionsCount);
+
+    void showLoginScreen();
+
+    void showConnectionError();
+
+    void showConnecting();
+
+    void showConnectionOk();
+  }
+
+  interface Presenter extends BaseContract.Presenter<View> {
+
+    void onOpenRoom(String hostname, String roomId);
+
+    void onRetryLogin();
+  }
+}

app/src/main/java/chat/rocket/android/activity/MainPresenter.java

+package chat.rocket.android.activity;
+
+import android.support.annotation.NonNull;
+import android.support.v4.util.Pair;
+
+import chat.rocket.android.BackgroundLooper;
+import chat.rocket.android.shared.BasePresenter;
+import chat.rocket.core.interactors.CanCreateRoomInteractor;
+import chat.rocket.core.interactors.RoomInteractor;
+import chat.rocket.core.interactors.SessionInteractor;
+import rx.Observable;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+
+public class MainPresenter extends BasePresenter<MainContract.View>
+    implements MainContract.Presenter {
+
+  private final CanCreateRoomInteractor canCreateRoomInteractor;
+  private final RoomInteractor roomInteractor;
+  private final SessionInteractor sessionInteractor;
+
+  public MainPresenter(RoomInteractor roomInteractor,
+                       CanCreateRoomInteractor canCreateRoomInteractor,
+                       SessionInteractor sessionInteractor) {
+    this.roomInteractor = roomInteractor;
+    this.canCreateRoomInteractor = canCreateRoomInteractor;
+    this.sessionInteractor = sessionInteractor;
+  }
+
+  @Override
+  public void bindView(@NonNull MainContract.View view) {
+    super.bindView(view);
+
+    subscribeToUnreadCount();
+    subscribeToSession();
+  }
+
+  @Override
+  public void onOpenRoom(String hostname, String roomId) {
+    final Subscription subscription = canCreateRoomInteractor.canCreate(roomId)
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(allowed -> {
+          if (allowed) {
+            view.showRoom(hostname, roomId);
+          } else {
+            view.showHome();
+          }
+        });
+
+    addSubscription(subscription);
+  }
+
+  @Override
+  public void onRetryLogin() {
+    final Subscription subscription = sessionInteractor.retryLogin()
+        .subscribe();
+
+    addSubscription(subscription);
+  }
+
+  private void subscribeToUnreadCount() {
+    final Subscription subscription = Observable.combineLatest(
+        roomInteractor.getTotalUnreadRoomsCount(),
+        roomInteractor.getTotalUnreadMentionsCount(),
+        (Pair::new)
+    )
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(pair -> view.showUnreadCount(pair.first, pair.second));
+
+    addSubscription(subscription);
+  }
+
+  private void subscribeToSession() {
+    final Subscription subscription = sessionInteractor.getDefault()
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(session -> {
+          if (session == null || session.getToken() == null) {
+            view.showLoginScreen();
+            return;
+          }
+
+          String error = session.getError();
+          if (error != null && error.length() != 0) {
+            view.showConnectionError();
+            return;
+          }
+
+          if (!session.isTokenVerified()) {
+            view.showConnecting();
+            return;
+          }
+
+          view.showConnectionOk();
+        });
+
+    addSubscription(subscription);
+  }
+}

app/src/main/java/chat/rocket/android/api/FileUploadingHelper.java

@@ -6,7 +6,7 @@ import org.json.JSONObject;
 
 import bolts.Task;
 import chat.rocket.android.helper.TextUtils;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
 /**

app/src/main/java/chat/rocket/android/api/MethodCallHelper.java

@@ -11,14 +11,15 @@ import bolts.Continuation;
 import bolts.Task;
 import chat.rocket.android.helper.CheckSum;
 import chat.rocket.android.helper.TextUtils;
-import chat.rocket.android.model.SyncState;
-import chat.rocket.android.model.ddp.Message;
-import chat.rocket.android.model.ddp.PublicSetting;
-import chat.rocket.android.model.ddp.RoomSubscription;
-import chat.rocket.android.model.internal.MethodCall;
-import chat.rocket.android.model.internal.Session;
-import chat.rocket.android.realm_helper.RealmHelper;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.android.service.ConnectivityManager;
+import chat.rocket.persistence.realm.models.ddp.RealmPublicSetting;
+import chat.rocket.core.SyncState;
+import chat.rocket.persistence.realm.models.ddp.RealmMessage;
+import chat.rocket.persistence.realm.models.ddp.RealmRoom;
+import chat.rocket.persistence.realm.models.internal.MethodCall;
+import chat.rocket.persistence.realm.models.internal.RealmSession;
+import chat.rocket.persistence.realm.RealmHelper;
+import chat.rocket.persistence.realm.RealmStore;
 import chat.rocket.android.service.DDPClientRef;
 import chat.rocket.android_ddp.DDPClientCallback;
 import hugo.weaving.DebugLog;
@@ -43,7 +44,7 @@ public class MethodCallHelper {
    * initialize with Context and hostname.
    */
   public MethodCallHelper(Context context, String hostname) {
-    this.context = context;
+    this.context = context.getApplicationContext();
     this.realmHelper = RealmStore.get(hostname);
     ddpClientRef = null;
   }
@@ -63,7 +64,12 @@ public class MethodCallHelper {
       return ddpClientRef.get().rpc(UUID.randomUUID().toString(), methodName, param, timeout)
           .onSuccessTask(task -> Task.forResult(task.getResult().result));
     } else {
-      return MethodCall.execute(context, realmHelper, methodName, param, timeout);
+      return MethodCall.execute(realmHelper, methodName, param, timeout)
+          .onSuccessTask(task -> {
+            ConnectivityManager.getInstance(context.getApplicationContext())
+                .keepAliveServer();
+            return task;
+          });
     }
   }
 
@@ -107,7 +113,7 @@ public class MethodCallHelper {
   }
 
   /**
-   * Register User.
+   * Register RealmUser.
    */
   public Task<String> registerUser(final String name, final String email,
                                    final String password, final String confirmPassword) {
@@ -120,8 +126,8 @@ public class MethodCallHelper {
 
   private Task<Void> saveToken(Task<String> task) {
     return realmHelper.executeTransaction(realm ->
-        realm.createOrUpdateObjectFromJson(Session.class, new JSONObject()
-            .put("sessionId", Session.DEFAULT_ID)
+        realm.createOrUpdateObjectFromJson(RealmSession.class, new JSONObject()
+            .put("sessionId", RealmSession.DEFAULT_ID)
             .put("token", task.getResult())
             .put("tokenVerified", true)
             .put("error", JSONObject.NULL)
@@ -185,7 +191,7 @@ public class MethodCallHelper {
         .onSuccessTask(this::saveToken)
         .continueWithTask(task -> {
           if (task.isFaulted()) {
-            Session.logError(realmHelper, task.getError());
+            RealmSession.logError(realmHelper, task.getError());
           }
           return task;
         });
@@ -197,7 +203,7 @@ public class MethodCallHelper {
   public Task<Void> logout() {
     return call("logout", TIMEOUT_MS).onSuccessTask(task ->
         realmHelper.executeTransaction(realm -> {
-          realm.delete(Session.class);
+          realm.delete(RealmSession.class);
           return null;
         }));
   }
@@ -211,13 +217,13 @@ public class MethodCallHelper {
           final JSONArray result = task.getResult();
           try {
             for (int i = 0; i < result.length(); i++) {
-              RoomSubscription.customizeJson(result.getJSONObject(i));
+              RealmRoom.customizeJson(result.getJSONObject(i));
             }
 
             return realmHelper.executeTransaction(realm -> {
-              realm.delete(RoomSubscription.class);
+              realm.delete(RealmRoom.class);
               realm.createOrUpdateAllFromJson(
-                  RoomSubscription.class, result);
+                  RealmRoom.class, result);
               return null;
             });
           } catch (JSONException exception) {
@@ -241,18 +247,18 @@ public class MethodCallHelper {
           JSONObject result = task.getResult();
           final JSONArray messages = result.getJSONArray("messages");
           for (int i = 0; i < messages.length(); i++) {
-            Message.customizeJson(messages.getJSONObject(i));
+            RealmMessage.customizeJson(messages.getJSONObject(i));
           }
 
           return realmHelper.executeTransaction(realm -> {
             if (timestamp == 0) {
-              realm.where(Message.class)
+              realm.where(RealmMessage.class)
                   .equalTo("rid", roomId)
                   .equalTo("syncstate", SyncState.SYNCED)
                   .findAll().deleteAllFromRealm();
             }
             if (messages.length() > 0) {
-              realm.createOrUpdateAllFromJson(Message.class, messages);
+              realm.createOrUpdateAllFromJson(RealmMessage.class, messages);
             }
             return null;
           }).onSuccessTask(_task -> Task.forResult(messages));
@@ -334,12 +340,12 @@ public class MethodCallHelper {
         .onSuccessTask(task -> {
           final JSONArray settings = task.getResult();
           for (int i = 0; i < settings.length(); i++) {
-            PublicSetting.customizeJson(settings.getJSONObject(i));
+            RealmPublicSetting.customizeJson(settings.getJSONObject(i));
           }
 
           return realmHelper.executeTransaction(realm -> {
-            realm.delete(PublicSetting.class);
-            realm.createOrUpdateAllFromJson(PublicSetting.class, settings);
+            realm.delete(RealmPublicSetting.class);
+            realm.createOrUpdateAllFromJson(RealmPublicSetting.class, settings);
             return null;
           });
         });

app/src/main/java/chat/rocket/android/api/RaixPushHelper.java

@@ -7,7 +7,7 @@ import org.json.JSONArray;
 import org.json.JSONObject;
 
 import bolts.Task;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
 public class RaixPushHelper extends MethodCallHelper {

app/src/main/java/chat/rocket/android/api/rest/DefaultCookieProvider.java

@@ -3,10 +3,10 @@ package chat.rocket.android.api.rest;
 import android.content.Context;
 
 import chat.rocket.android.RocketChatCache;
-import chat.rocket.android.model.ddp.User;
-import chat.rocket.android.model.internal.Session;
-import chat.rocket.android.realm_helper.RealmHelper;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.persistence.realm.models.ddp.RealmUser;
+import chat.rocket.persistence.realm.models.internal.RealmSession;
+import chat.rocket.persistence.realm.RealmHelper;
+import chat.rocket.persistence.realm.RealmStore;
 
 public class DefaultCookieProvider implements CookieProvider {
 
@@ -33,10 +33,10 @@ public class DefaultCookieProvider implements CookieProvider {
       return "";
     }
 
-    final User user = realmHelper.executeTransactionForRead(realm ->
-        User.queryCurrentUser(realm).findFirst());
-    final Session session = realmHelper.executeTransactionForRead(realm ->
-        Session.queryDefaultSession(realm).findFirst());
+    final RealmUser user = realmHelper.executeTransactionForRead(realm ->
+        RealmUser.queryCurrentUser(realm).findFirst());
+    final RealmSession session = realmHelper.executeTransactionForRead(realm ->
+        RealmSession.queryDefaultSession(realm).findFirst());
 
     if (user == null || session == null) {
       return "";

app/src/main/java/chat/rocket/android/fragment/AbstractWebViewFragment.java

@@ -104,6 +104,4 @@ public abstract class AbstractWebViewFragment extends AbstractFragment
   protected boolean onHandleCallback(WebView webview, String url) {
     return false;
   }
-
-  ;
 }

app/src/main/java/chat/rocket/android/fragment/add_server/InputHostnameContract.java

+package chat.rocket.android.fragment.add_server;
+
+import chat.rocket.android.shared.BaseContract;
+
+public interface InputHostnameContract {
+
+  interface View extends BaseContract.View {
+    void showLoader();
+
+    void hideLoader();
+
+    void showInvalidServerError();
+
+    void showConnectionError();
+
+    void showHome();
+  }
+
+  interface Presenter extends BaseContract.Presenter<View> {
+
+    void connectTo(String hostname);
+  }
+
+}

app/src/main/java/chat/rocket/android/fragment/add_server/InputHostnameFragment.java

 package chat.rocket.android.fragment.add_server;
 
+import android.content.Context;
+import android.os.Bundle;
+import android.support.annotation.Nullable;
 import android.support.design.widget.Snackbar;
+import android.view.View;
 import android.widget.TextView;
 
 import chat.rocket.android.BuildConfig;
 import chat.rocket.android.LaunchUtil;
 import chat.rocket.android.R;
 import chat.rocket.android.RocketChatCache;
-import chat.rocket.android.api.rest.DefaultServerPolicyApi;
-import chat.rocket.android.api.rest.ServerPolicyApi;
 import chat.rocket.android.fragment.AbstractFragment;
-import chat.rocket.android.helper.OkHttpHelper;
-import chat.rocket.android.helper.ServerPolicyApiValidationHelper;
-import chat.rocket.android.helper.ServerPolicyHelper;
 import chat.rocket.android.helper.TextUtils;
 import chat.rocket.android.service.ConnectivityManager;
-import chat.rocket.android.service.ConnectivityManagerApi;
-import rx.Subscription;
-import rx.android.schedulers.AndroidSchedulers;
-import rx.schedulers.Schedulers;
 
 /**
  * Input server host.
  */
-public class InputHostnameFragment extends AbstractFragment {
-  Subscription serverPolicySubscription;
+public class InputHostnameFragment extends AbstractFragment implements InputHostnameContract.View {
+
+  private InputHostnameContract.Presenter presenter;
 
   public InputHostnameFragment() {
   }
 
+  @Override
+  public void onCreate(@Nullable Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    final Context appContext = getContext().getApplicationContext();
+
+    presenter = new InputHostnamePresenter(
+        RocketChatCache.get(appContext),
+        ConnectivityManager.getInstance(appContext));
+  }
+
   @Override
   protected int getLayout() {
     return R.layout.fragment_input_hostname;
@@ -47,42 +54,18 @@ public class InputHostnameFragment extends AbstractFragment {
   }
 
   private void handleConnect() {
-    final String hostname = ServerPolicyHelper.enforceHostname(getHostname());
-
-    final ServerPolicyApi serverPolicyApi =
-        new DefaultServerPolicyApi(OkHttpHelper.getClientForUploadFile(), hostname);
-
-    final ServerPolicyApiValidationHelper validationHelper =
-        new ServerPolicyApiValidationHelper(serverPolicyApi);
-
-    if (serverPolicySubscription != null) {
-      serverPolicySubscription.unsubscribe();
-    }
-
-    rootView.findViewById(R.id.btn_connect).setEnabled(false);
+    presenter.connectTo(getHostname());
+  }
 
-    serverPolicySubscription = ServerPolicyHelper.isApiVersionValid(validationHelper)
-        .subscribeOn(Schedulers.io())
-        .observeOn(AndroidSchedulers.mainThread())
-        .doOnTerminate(() -> rootView.findViewById(R.id.btn_connect).setEnabled(true))
-        .subscribe(
-            serverValidation -> {
-              if (serverValidation.isValid()) {
-                onServerValid(hostname, serverValidation.usesSecureConnection());
-              } else {
-                showError(getString(R.string.input_hostname_invalid_server_message));
-              }
-            },
-            throwable -> {
-              showError(getString(R.string.connection_error_try_later));
-            });
+  @Override
+  public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
+    super.onViewCreated(view, savedInstanceState);
+    presenter.bindView(this);
   }
 
   @Override
   public void onDestroyView() {
-    if (serverPolicySubscription != null) {
-      serverPolicySubscription.unsubscribe();
-    }
+    presenter.release();
     super.onDestroyView();
   }
 
@@ -92,21 +75,33 @@ public class InputHostnameFragment extends AbstractFragment {
     return TextUtils.or(TextUtils.or(editor.getText(), editor.getHint()), "").toString();
   }
 
-  private void onServerValid(final String hostname, boolean usesSecureConnection) {
-    RocketChatCache.get(getContext()).edit()
-        .putString(RocketChatCache.KEY_SELECTED_SERVER_HOSTNAME, hostname)
-        .apply();
+  private void showError(String errString) {
+    Snackbar.make(rootView, errString, Snackbar.LENGTH_LONG).show();
+  }
 
-    ConnectivityManagerApi connectivityManager =
-        ConnectivityManager.getInstance(getContext().getApplicationContext());
-    connectivityManager.addOrUpdateServer(hostname, hostname, !usesSecureConnection);
-    connectivityManager.keepAliveServer();
+  @Override
+  public void showLoader() {
+    rootView.findViewById(R.id.btn_connect).setEnabled(false);
+  }
 
-    LaunchUtil.showMainActivity(getContext());
-    getActivity().overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out);
+  @Override
+  public void hideLoader() {
+    rootView.findViewById(R.id.btn_connect).setEnabled(true);
   }
 
-  private void showError(String errString) {
-    Snackbar.make(rootView, errString, Snackbar.LENGTH_LONG).show();
+  @Override
+  public void showInvalidServerError() {
+    showError(getString(R.string.input_hostname_invalid_server_message));
+  }
+
+  @Override
+  public void showConnectionError() {
+    showError(getString(R.string.connection_error_try_later));
+  }
+
+  @Override
+  public void showHome() {
+    LaunchUtil.showMainActivity(getContext());
+    getActivity().overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out);
   }
 }

app/src/main/java/chat/rocket/android/fragment/add_server/InputHostnamePresenter.java

+package chat.rocket.android.fragment.add_server;
+
+import android.content.SharedPreferences;
+
+import chat.rocket.android.RocketChatCache;
+import chat.rocket.android.api.rest.DefaultServerPolicyApi;
+import chat.rocket.android.api.rest.ServerPolicyApi;
+import chat.rocket.android.helper.OkHttpHelper;
+import chat.rocket.android.helper.ServerPolicyApiValidationHelper;
+import chat.rocket.android.helper.ServerPolicyHelper;
+import chat.rocket.android.service.ConnectivityManagerApi;
+import chat.rocket.android.shared.BasePresenter;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.schedulers.Schedulers;
+
+public class InputHostnamePresenter extends BasePresenter<InputHostnameContract.View>
+    implements InputHostnameContract.Presenter {
+
+  private final SharedPreferences rocketChatCache;
+  private final ConnectivityManagerApi connectivityManager;
+
+  public InputHostnamePresenter(SharedPreferences rocketChatCache,
+                                ConnectivityManagerApi connectivityManager) {
+    this.rocketChatCache = rocketChatCache;
+    this.connectivityManager = connectivityManager;
+  }
+
+  @Override
+  public void connectTo(final String hostname) {
+    view.showLoader();
+
+    connectToEnforced(ServerPolicyHelper.enforceHostname(hostname));
+  }
+
+  public void connectToEnforced(final String hostname) {
+    final ServerPolicyApi serverPolicyApi =
+        new DefaultServerPolicyApi(OkHttpHelper.getClientForUploadFile(), hostname);
+
+    final ServerPolicyApiValidationHelper validationHelper =
+        new ServerPolicyApiValidationHelper(serverPolicyApi);
+
+    clearSubscripions();
+
+    final Subscription subscription = ServerPolicyHelper.isApiVersionValid(validationHelper)
+        .subscribeOn(Schedulers.io())
+        .observeOn(AndroidSchedulers.mainThread())
+        .doOnTerminate(() -> view.hideLoader())
+        .subscribe(
+            serverValidation -> {
+              if (serverValidation.isValid()) {
+                onServerValid(hostname, serverValidation.usesSecureConnection());
+              } else {
+                view.showInvalidServerError();
+              }
+            },
+            throwable -> {
+              view.showConnectionError();
+            });
+
+    addSubscription(subscription);
+  }
+
+  private void onServerValid(final String hostname, boolean usesSecureConnection) {
+    rocketChatCache.edit()
+        .putString(RocketChatCache.KEY_SELECTED_SERVER_HOSTNAME, hostname)
+        .apply();
+
+    connectivityManager.addOrUpdateServer(hostname, hostname, !usesSecureConnection);
+    connectivityManager.keepAliveServer();
+
+    view.showHome();
+  }
+}

app/src/main/java/chat/rocket/android/fragment/chatroom/RoomContract.java

+package chat.rocket.android.fragment.chatroom;
+
+import android.support.annotation.Nullable;
+
+import java.util.List;
+import chat.rocket.android.shared.BaseContract;
+import chat.rocket.core.models.Message;
+import chat.rocket.core.models.Room;
+
+public interface RoomContract {
+
+  interface View extends BaseContract.View {
+
+    void render(Room room);
+
+    void updateHistoryState(boolean hasNext, boolean isLoaded);
+
+    void onMessageSendSuccessfully();
+
+    void showUnreadCount(int count);
+
+    void showMessages(List<Message> messages);
+
+    void showMessageSendFailure(Message message);
+  }
+
+  interface Presenter extends BaseContract.Presenter<View> {
+
+    void loadMessages();
+
+    void loadMoreMessages();
+
+    void onMessageSelected(@Nullable Message message);
+
+    void sendMessage(String messageText);
+
+    void resendMessage(Message message);
+
+    void deleteMessage(Message message);
+
+    void onUnreadCount();
+
+    void onMarkAsRead();
+  }
+}

app/src/main/java/chat/rocket/android/fragment/chatroom/RoomPresenter.java

+package chat.rocket.android.fragment.chatroom;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.v4.util.Pair;
+
+import chat.rocket.android.BackgroundLooper;
+import chat.rocket.android.api.MethodCallHelper;
+import chat.rocket.android.helper.LogcatIfError;
+import chat.rocket.android.shared.BasePresenter;
+import chat.rocket.core.SyncState;
+import chat.rocket.core.interactors.MessageInteractor;
+import chat.rocket.core.models.Message;
+import chat.rocket.core.models.Room;
+import chat.rocket.core.models.User;
+import chat.rocket.core.repositories.RoomRepository;
+import chat.rocket.core.repositories.UserRepository;
+import chat.rocket.android.service.ConnectivityManagerApi;
+import rx.Single;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+
+public class RoomPresenter extends BasePresenter<RoomContract.View>
+    implements RoomContract.Presenter {
+
+  private final String roomId;
+  private final MessageInteractor messageInteractor;
+  private final UserRepository userRepository;
+  private final RoomRepository roomRepository;
+  private final MethodCallHelper methodCallHelper;
+  private final ConnectivityManagerApi connectivityManagerApi;
+
+  public RoomPresenter(String roomId,
+                       UserRepository userRepository,
+                       MessageInteractor messageInteractor,
+                       RoomRepository roomRepository,
+                       MethodCallHelper methodCallHelper,
+                       ConnectivityManagerApi connectivityManagerApi) {
+    this.roomId = roomId;
+    this.userRepository = userRepository;
+    this.messageInteractor = messageInteractor;
+    this.roomRepository = roomRepository;
+    this.methodCallHelper = methodCallHelper;
+    this.connectivityManagerApi = connectivityManagerApi;
+  }
+
+  @Override
+  public void bindView(@NonNull RoomContract.View view) {
+    super.bindView(view);
+
+    getRoomInfo();
+    getRoomHistoryStateInfo();
+    getMessages();
+  }
+
+  @Override
+  public void loadMessages() {
+    final Subscription subscription = getSingleRoom()
+        .flatMap(messageInteractor::loadMessages)
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(success -> {
+          if (success) {
+            connectivityManagerApi.keepAliveServer();
+          }
+        });
+
+    addSubscription(subscription);
+  }
+
+  @Override
+  public void loadMoreMessages() {
+
+    final Subscription subscription = getSingleRoom()
+        .flatMap(messageInteractor::loadMoreMessages)
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(success -> {
+          if (success) {
+            connectivityManagerApi.keepAliveServer();
+          }
+        });
+
+    addSubscription(subscription);
+  }
+
+  @Override
+  public void onMessageSelected(@Nullable Message message) {
+    if (message == null) {
+      return;
+    }
+
+    if (message.getSyncState() == SyncState.FAILED) {
+      view.showMessageSendFailure(message);
+    }
+  }
+
+  @Override
+  public void sendMessage(String messageText) {
+    final Subscription subscription = getRoomUserPair()
+        .flatMap(pair -> messageInteractor.send(pair.first, pair.second, messageText))
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(success -> {
+          if (success) {
+            view.onMessageSendSuccessfully();
+          }
+        });
+
+    addSubscription(subscription);
+  }
+
+  @Override
+  public void resendMessage(Message message) {
+    final Subscription subscription = messageInteractor.resend(message)
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe();
+
+    addSubscription(subscription);
+  }
+
+  @Override
+  public void deleteMessage(Message message) {
+    final Subscription subscription = messageInteractor.delete(message)
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe();
+
+    addSubscription(subscription);
+  }
+
+  @Override
+  public void onUnreadCount() {
+    final Subscription subscription = getRoomUserPair()
+        .flatMap(roomUserPair -> messageInteractor
+            .unreadCountFor(roomUserPair.first, roomUserPair.second))
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(
+            count -> view.showUnreadCount(count)
+        );
+
+    addSubscription(subscription);
+  }
+
+  @Override
+  public void onMarkAsRead() {
+    final Subscription subscription = roomRepository.getById(roomId)
+        .first()
+        .filter(room -> room != null && room.isAlert())
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(
+            room -> methodCallHelper.readMessages(room.getRoomId())
+                .continueWith(new LogcatIfError())
+        );
+
+    addSubscription(subscription);
+  }
+
+  private void getRoomInfo() {
+    final Subscription subscription = roomRepository.getById(roomId)
+        .distinctUntilChanged()
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(
+            room -> view.render(room)
+        );
+
+    addSubscription(subscription);
+  }
+
+  private void getRoomHistoryStateInfo() {
+    final Subscription subscription = roomRepository.getHistoryStateByRoomId(roomId)
+        .distinctUntilChanged()
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(
+            roomHistoryState -> {
+              int syncState = roomHistoryState.getSyncState();
+              view.updateHistoryState(
+                  !roomHistoryState.isComplete(),
+                  syncState == SyncState.SYNCED || syncState == SyncState.FAILED
+              );
+            }
+        );
+
+    addSubscription(subscription);
+  }
+
+  private void getMessages() {
+    final Subscription subscription = roomRepository.getById(roomId)
+        .first()
+        .flatMap(messageInteractor::getAllFrom)
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(messages -> view.showMessages(messages));
+
+    addSubscription(subscription);
+  }
+
+  private Single<Pair<Room, User>> getRoomUserPair() {
+    return Single.zip(
+        getSingleRoom(),
+        userRepository.getCurrent()
+            .filter(user -> user != null)
+            .first()
+            .toSingle(),
+        Pair::new
+    );
+  }
+
+  private Single<Room> getSingleRoom() {
+    return roomRepository.getById(roomId)
+        .first()
+        .toSingle();
+  }
+}

app/src/main/java/chat/rocket/android/fragment/chatroom/dialog/AbstractChatRoomDialogFragment.java

@@ -7,8 +7,8 @@ import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.support.design.widget.BottomSheetDialogFragment;
 
-import chat.rocket.android.realm_helper.RealmHelper;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.persistence.realm.RealmHelper;
+import chat.rocket.persistence.realm.RealmStore;
 
 abstract class AbstractChatRoomDialogFragment extends BottomSheetDialogFragment {
 

app/src/main/java/chat/rocket/android/fragment/chatroom/dialog/FileUploadProgressDialogFragment.java

@@ -9,9 +9,9 @@ import android.widget.TextView;
 import android.widget.Toast;
 
 import chat.rocket.android.R;
-import chat.rocket.android.model.SyncState;
-import chat.rocket.android.model.internal.FileUploading;
-import chat.rocket.android.realm_helper.RealmObjectObserver;
+import chat.rocket.core.SyncState;
+import chat.rocket.persistence.realm.models.internal.FileUploading;
+import chat.rocket.persistence.realm.RealmObjectObserver;
 import chat.rocket.android.renderer.FileUploadingRenderer;
 
 /**

app/src/main/java/chat/rocket/android/fragment/chatroom/dialog/UsersOfRoomDialogFragment.java

@@ -17,9 +17,9 @@ import chat.rocket.android.R;
 import chat.rocket.android.helper.LogcatIfError;
 import chat.rocket.android.layouthelper.chatroom.dialog.RoomUserAdapter;
 import chat.rocket.android.log.RCLog;
-import chat.rocket.android.model.SyncState;
-import chat.rocket.android.model.internal.GetUsersOfRoomsProcedure;
-import chat.rocket.android.realm_helper.RealmObjectObserver;
+import chat.rocket.core.SyncState;
+import chat.rocket.persistence.realm.models.internal.GetUsersOfRoomsProcedure;
+import chat.rocket.persistence.realm.RealmObjectObserver;
 import chat.rocket.android.service.ConnectivityManager;
 
 /**

app/src/main/java/chat/rocket/android/fragment/oauth/AbstractOAuthFragment.java

@@ -14,8 +14,8 @@ import chat.rocket.android.api.MethodCallHelper;
 import chat.rocket.android.fragment.AbstractWebViewFragment;
 import chat.rocket.android.helper.LogcatIfError;
 import chat.rocket.android.log.RCLog;
-import chat.rocket.android.model.ddp.MeteorLoginServiceConfiguration;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.persistence.realm.models.ddp.RealmMeteorLoginServiceConfiguration;
+import chat.rocket.persistence.realm.RealmStore;
 
 public abstract class AbstractOAuthFragment extends AbstractWebViewFragment {
 
@@ -25,7 +25,7 @@ public abstract class AbstractOAuthFragment extends AbstractWebViewFragment {
 
   protected abstract String getOAuthServiceName();
 
-  protected abstract String generateURL(MeteorLoginServiceConfiguration oauthConfig);
+  protected abstract String generateURL(RealmMeteorLoginServiceConfiguration oauthConfig);
 
   private boolean hasValidArgs(Bundle args) {
     return args != null
@@ -54,10 +54,10 @@ public abstract class AbstractOAuthFragment extends AbstractWebViewFragment {
     }
 
     hostname = args.getString("hostname");
-    MeteorLoginServiceConfiguration oauthConfig =
+    RealmMeteorLoginServiceConfiguration oauthConfig =
         RealmStore.get(hostname).executeTransactionForRead(realm ->
-            realm.where(MeteorLoginServiceConfiguration.class)
-                .equalTo(MeteorLoginServiceConfiguration.SERVICE, getOAuthServiceName())
+            realm.where(RealmMeteorLoginServiceConfiguration.class)
+                .equalTo(RealmMeteorLoginServiceConfiguration.SERVICE, getOAuthServiceName())
                 .findFirst());
     if (oauthConfig == null) {
       throw new IllegalArgumentException(

app/src/main/java/chat/rocket/android/fragment/oauth/FacebookOAuthFragment.java

 package chat.rocket.android.fragment.oauth;
 
-import chat.rocket.android.model.ddp.MeteorLoginServiceConfiguration;
+import chat.rocket.persistence.realm.models.ddp.RealmMeteorLoginServiceConfiguration;
 import okhttp3.HttpUrl;
 
 public class FacebookOAuthFragment extends AbstractOAuthFragment {
@@ -11,7 +11,7 @@ public class FacebookOAuthFragment extends AbstractOAuthFragment {
   }
 
   @Override
-  protected String generateURL(MeteorLoginServiceConfiguration oauthConfig) {
+  protected String generateURL(RealmMeteorLoginServiceConfiguration oauthConfig) {
     return new HttpUrl.Builder().scheme("https")
         .host("www.facebook.com")
         .addPathSegment("v2.2")

app/src/main/java/chat/rocket/android/fragment/oauth/GitHubOAuthFragment.java

 package chat.rocket.android.fragment.oauth;
 
-import chat.rocket.android.model.ddp.MeteorLoginServiceConfiguration;
+import chat.rocket.persistence.realm.models.ddp.RealmMeteorLoginServiceConfiguration;
 import okhttp3.HttpUrl;
 
 public class GitHubOAuthFragment extends AbstractOAuthFragment {
@@ -11,7 +11,7 @@ public class GitHubOAuthFragment extends AbstractOAuthFragment {
   }
 
   @Override
-  protected String generateURL(MeteorLoginServiceConfiguration oauthConfig) {
+  protected String generateURL(RealmMeteorLoginServiceConfiguration oauthConfig) {
     return new HttpUrl.Builder().scheme("https")
         .host("github.com")
         .addPathSegment("login")

app/src/main/java/chat/rocket/android/fragment/oauth/GoogleOAuthFragment.java

 package chat.rocket.android.fragment.oauth;
 
-import chat.rocket.android.model.ddp.MeteorLoginServiceConfiguration;
+import chat.rocket.persistence.realm.models.ddp.RealmMeteorLoginServiceConfiguration;
 import okhttp3.HttpUrl;
 
 public class GoogleOAuthFragment extends AbstractOAuthFragment {
@@ -11,7 +11,7 @@ public class GoogleOAuthFragment extends AbstractOAuthFragment {
   }
 
   @Override
-  protected String generateURL(MeteorLoginServiceConfiguration oauthConfig) {
+  protected String generateURL(RealmMeteorLoginServiceConfiguration oauthConfig) {
     return new HttpUrl.Builder().scheme("https")
         .host("accounts.google.com")
         .addPathSegment("o")

app/src/main/java/chat/rocket/android/fragment/oauth/TwitterOAuthFragment.java

 package chat.rocket.android.fragment.oauth;
 
-import chat.rocket.android.model.ddp.MeteorLoginServiceConfiguration;
+import chat.rocket.persistence.realm.models.ddp.RealmMeteorLoginServiceConfiguration;
 
 public class TwitterOAuthFragment extends AbstractOAuthFragment {
 
@@ -10,7 +10,7 @@ public class TwitterOAuthFragment extends AbstractOAuthFragment {
   }
 
   @Override
-  protected String generateURL(MeteorLoginServiceConfiguration oauthConfig) {
+  protected String generateURL(RealmMeteorLoginServiceConfiguration oauthConfig) {
     return "https://" + hostname + "/_oauth/twitter/"
         + "?requestTokenAndRedirect=true&state=" + getStateString();
   }

app/src/main/java/chat/rocket/android/fragment/server_config/LoginFragment.java

@@ -14,15 +14,15 @@ import chat.rocket.android.api.MethodCallHelper;
 import chat.rocket.android.helper.TextUtils;
 import chat.rocket.android.layouthelper.oauth.OAuthProviderInfo;
 import chat.rocket.android.log.RCLog;
-import chat.rocket.android.model.ddp.MeteorLoginServiceConfiguration;
-import chat.rocket.android.realm_helper.RealmListObserver;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.persistence.realm.models.ddp.RealmMeteorLoginServiceConfiguration;
+import chat.rocket.persistence.realm.RealmListObserver;
+import chat.rocket.persistence.realm.RealmStore;
 
 /**
  * Login screen.
  */
 public class LoginFragment extends AbstractServerConfigFragment {
-  private RealmListObserver<MeteorLoginServiceConfiguration> authProvidersObserver;
+  private RealmListObserver<RealmMeteorLoginServiceConfiguration> authProvidersObserver;
 
   @Override
   protected int getLayout() {
@@ -33,7 +33,7 @@ public class LoginFragment extends AbstractServerConfigFragment {
   public void onCreate(@Nullable Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     authProvidersObserver = RealmStore.get(hostname)
-        .createListObserver(realm -> realm.where(MeteorLoginServiceConfiguration.class).findAll())
+        .createListObserver(realm -> realm.where(RealmMeteorLoginServiceConfiguration.class).findAll())
         .setOnUpdateListener(this::onRenderAuthProviders);
   }
 
@@ -74,7 +74,7 @@ public class LoginFragment extends AbstractServerConfigFragment {
     Snackbar.make(rootView, errString, Snackbar.LENGTH_SHORT).show();
   }
 
-  private void onRenderAuthProviders(List<MeteorLoginServiceConfiguration> authProviders) {
+  private void onRenderAuthProviders(List<RealmMeteorLoginServiceConfiguration> authProviders) {
     HashMap<String, View> viewMap = new HashMap<>();
     HashMap<String, Boolean> supportedMap = new HashMap<>();
     for (OAuthProviderInfo info : OAuthProviderInfo.LIST) {
@@ -82,7 +82,7 @@ public class LoginFragment extends AbstractServerConfigFragment {
       supportedMap.put(info.serviceName, false);
     }
 
-    for (MeteorLoginServiceConfiguration authProvider : authProviders) {
+    for (RealmMeteorLoginServiceConfiguration authProvider : authProviders) {
       for (OAuthProviderInfo info : OAuthProviderInfo.LIST) {
         if (!supportedMap.get(info.serviceName)
             && info.serviceName.equals(authProvider.getService())) {

app/src/main/java/chat/rocket/android/fragment/server_config/RetryLoginFragment.java

@@ -8,15 +8,15 @@ import android.widget.TextView;
 import chat.rocket.android.R;
 import chat.rocket.android.api.MethodCallHelper;
 import chat.rocket.android.helper.TextUtils;
-import chat.rocket.android.model.internal.Session;
-import chat.rocket.android.realm_helper.RealmObjectObserver;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.persistence.realm.models.internal.RealmSession;
+import chat.rocket.persistence.realm.RealmObjectObserver;
+import chat.rocket.persistence.realm.RealmStore;
 
 /**
  * Login screen.
  */
 public class RetryLoginFragment extends AbstractServerConfigFragment {
-  private RealmObjectObserver<Session> sessionObserver;
+  private RealmObjectObserver<RealmSession> sessionObserver;
 
   @Override
   protected int getLayout() {
@@ -27,7 +27,7 @@ public class RetryLoginFragment extends AbstractServerConfigFragment {
   public void onCreate(@Nullable Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     sessionObserver = RealmStore.get(hostname)
-        .createObjectObserver(Session::queryDefaultSession)
+        .createObjectObserver(RealmSession::queryDefaultSession)
         .setOnUpdateListener(this::onRenderServerConfigSession);
   }
 
@@ -35,7 +35,7 @@ public class RetryLoginFragment extends AbstractServerConfigFragment {
   protected void onSetupView() {
   }
 
-  private void onRenderServerConfigSession(Session session) {
+  private void onRenderServerConfigSession(RealmSession session) {
     if (session == null) {
       return;
     }

app/src/main/java/chat/rocket/android/fragment/sidebar/SidebarMainContract.java

+package chat.rocket.android.fragment.sidebar;
+
+import java.util.List;
+import chat.rocket.android.shared.BaseContract;
+import chat.rocket.core.models.Room;
+import chat.rocket.core.models.User;
+
+public interface SidebarMainContract {
+
+  interface View extends BaseContract.View {
+
+    void showScreen();
+
+    void showEmptyScreen();
+
+    void showRoomList(List<Room> roomList);
+
+    void showUser(User user);
+  }
+
+  interface Presenter extends BaseContract.Presenter<View> {
+
+    void onUserOnline();
+
+    void onUserAway();
+
+    void onUserBusy();
+
+    void onUserOffline();
+
+    void onLogout();
+  }
+}

app/src/main/java/chat/rocket/android/fragment/sidebar/SidebarMainFragment.java

@@ -3,6 +3,7 @@ package chat.rocket.android.fragment.sidebar;
 import android.os.Bundle;
 import android.support.annotation.Nullable;
 import android.support.v4.app.DialogFragment;
+import android.view.View;
 import android.widget.CompoundButton;
 import android.widget.ImageView;
 import android.widget.LinearLayout;
@@ -10,6 +11,7 @@ import android.widget.TextView;
 import com.jakewharton.rxbinding.view.RxView;
 import com.jakewharton.rxbinding.widget.RxCompoundButton;
 
+import java.util.List;
 import chat.rocket.android.BuildConfig;
 import chat.rocket.android.R;
 import chat.rocket.android.RocketChatCache;
@@ -18,25 +20,25 @@ import chat.rocket.android.fragment.AbstractFragment;
 import chat.rocket.android.fragment.sidebar.dialog.AbstractAddRoomDialogFragment;
 import chat.rocket.android.fragment.sidebar.dialog.AddChannelDialogFragment;
 import chat.rocket.android.fragment.sidebar.dialog.AddDirectMessageDialogFragment;
-import chat.rocket.android.helper.LogcatIfError;
 import chat.rocket.android.helper.TextUtils;
 import chat.rocket.android.layouthelper.chatroom.RoomListManager;
-import chat.rocket.android.model.ddp.RoomSubscription;
-import chat.rocket.android.model.ddp.User;
-import chat.rocket.android.realm_helper.RealmHelper;
-import chat.rocket.android.realm_helper.RealmListObserver;
-import chat.rocket.android.realm_helper.RealmObjectObserver;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.core.interactors.RoomInteractor;
+import chat.rocket.core.models.Room;
+import chat.rocket.core.models.User;
 import chat.rocket.android.renderer.UserRenderer;
+import chat.rocket.persistence.realm.repositories.RealmRoomRepository;
+import chat.rocket.persistence.realm.repositories.RealmUserRepository;
 import chat.rocket.android.widget.RocketChatAvatar;
 
-public class SidebarMainFragment extends AbstractFragment {
+public class SidebarMainFragment extends AbstractFragment implements SidebarMainContract.View {
+
+  private static final String HOSTNAME = "hostname";
+
+  private SidebarMainContract.Presenter presenter;
 
-  private String hostname;
   private RoomListManager roomListManager;
-  private RealmListObserver<RoomSubscription> roomsObserver;
-  private RealmObjectObserver<User> currentUserObserver;
-  private MethodCallHelper methodCallHelper;
+
+  private String hostname;
 
   public SidebarMainFragment() {
   }
@@ -46,10 +48,11 @@ public class SidebarMainFragment extends AbstractFragment {
    */
   public static SidebarMainFragment create(String hostname) {
     Bundle args = new Bundle();
-    args.putString("hostname", hostname);
+    args.putString(HOSTNAME, hostname);
 
     SidebarMainFragment fragment = new SidebarMainFragment();
     fragment.setArguments(args);
+
     return fragment;
   }
 
@@ -58,40 +61,35 @@ public class SidebarMainFragment extends AbstractFragment {
     super.onCreate(savedInstanceState);
 
     Bundle args = getArguments();
-    hostname = args == null ? null : args.getString("hostname");
-    if (!TextUtils.isEmpty(hostname)) {
-      RealmHelper realmHelper = RealmStore.get(hostname);
-      if (realmHelper != null) {
-        roomsObserver = realmHelper
-            .createListObserver(
-                realm -> realm.where(RoomSubscription.class).equalTo(RoomSubscription.OPEN, true)
-                    .findAll())
-            .setOnUpdateListener(list -> roomListManager.setRooms(list));
-
-        currentUserObserver = realmHelper
-            .createObjectObserver(User::queryCurrentUser)
-            .setOnUpdateListener(this::onCurrentUser);
-
-        methodCallHelper = new MethodCallHelper(getContext(), hostname);
-      }
-    }
+    hostname = args == null ? null : args.getString(HOSTNAME);
+
+    presenter = new SidebarMainPresenter(
+        hostname,
+        new RoomInteractor(new RealmRoomRepository(hostname)),
+        new RealmUserRepository(hostname),
+        TextUtils.isEmpty(hostname) ? null : new MethodCallHelper(getContext(), hostname)
+    );
+  }
+
+  @Override
+  public void onResume() {
+    super.onResume();
+    presenter.bindView(this);
+  }
+
+  @Override
+  public void onPause() {
+    presenter.release();
+    super.onPause();
   }
 
   @Override
   protected int getLayout() {
-    if (hostname == null) {
-      return R.layout.simple_screen;
-    } else {
-      return R.layout.fragment_sidebar_main;
-    }
+    return R.layout.fragment_sidebar_main;
   }
 
   @Override
   protected void onSetupView() {
-    if (hostname == null) {
-      return;
-    }
-
     setupUserActionToggle();
     setupUserStatusButtons();
     setupLogoutButton();
@@ -123,26 +121,22 @@ public class SidebarMainFragment extends AbstractFragment {
   }
 
   private void setupUserStatusButtons() {
-    rootView.findViewById(R.id.btn_status_online).setOnClickListener(view ->
-        updateCurrentUserStatus(User.STATUS_ONLINE));
-    rootView.findViewById(R.id.btn_status_away).setOnClickListener(view ->
-        updateCurrentUserStatus(User.STATUS_AWAY));
-    rootView.findViewById(R.id.btn_status_busy).setOnClickListener(view ->
-        updateCurrentUserStatus(User.STATUS_BUSY));
-    rootView.findViewById(R.id.btn_status_invisible).setOnClickListener(view ->
-        updateCurrentUserStatus(User.STATUS_OFFLINE));
-  }
-
-  private void updateCurrentUserStatus(String status) {
-    if (methodCallHelper != null) {
-      methodCallHelper.setUserStatus(status).continueWith(new LogcatIfError());
+    rootView.findViewById(R.id.btn_status_online).setOnClickListener(view -> {
+      presenter.onUserOnline();
       closeUserActionContainer();
-    }
-  }
-
-  private void onCurrentUser(User user) {
-    onRenderCurrentUser(user);
-    updateRoomListMode(user);
+    });
+    rootView.findViewById(R.id.btn_status_away).setOnClickListener(view -> {
+      presenter.onUserAway();
+      closeUserActionContainer();
+    });
+    rootView.findViewById(R.id.btn_status_busy).setOnClickListener(view -> {
+      presenter.onUserBusy();
+      closeUserActionContainer();
+    });
+    rootView.findViewById(R.id.btn_status_invisible).setOnClickListener(view -> {
+      presenter.onUserOffline();
+      closeUserActionContainer();
+    });
   }
 
   private void onRenderCurrentUser(User user) {
@@ -163,10 +157,8 @@ public class SidebarMainFragment extends AbstractFragment {
 
   private void setupLogoutButton() {
     rootView.findViewById(R.id.btn_logout).setOnClickListener(view -> {
-      if (methodCallHelper != null) {
-        methodCallHelper.logout().continueWith(new LogcatIfError());
-        closeUserActionContainer();
-      }
+      presenter.onLogout();
+      closeUserActionContainer();
     });
   }
 
@@ -198,20 +190,23 @@ public class SidebarMainFragment extends AbstractFragment {
   }
 
   @Override
-  public void onResume() {
-    super.onResume();
-    if (roomsObserver != null) {
-      roomsObserver.sub();
-      currentUserObserver.sub();
-    }
+  public void showScreen() {
+    rootView.setVisibility(View.VISIBLE);
   }
 
   @Override
-  public void onPause() {
-    if (roomsObserver != null) {
-      currentUserObserver.unsub();
-      roomsObserver.unsub();
-    }
-    super.onPause();
+  public void showEmptyScreen() {
+    rootView.setVisibility(View.INVISIBLE);
+  }
+
+  @Override
+  public void showRoomList(List<Room> roomList) {
+    roomListManager.setRooms(roomList);
+  }
+
+  @Override
+  public void showUser(User user) {
+    onRenderCurrentUser(user);
+    updateRoomListMode(user);
   }
 }

app/src/main/java/chat/rocket/android/fragment/sidebar/SidebarMainPresenter.java

+package chat.rocket.android.fragment.sidebar;
+
+import android.support.annotation.NonNull;
+
+import chat.rocket.android.BackgroundLooper;
+import chat.rocket.android.api.MethodCallHelper;
+import chat.rocket.android.helper.LogcatIfError;
+import chat.rocket.android.helper.TextUtils;
+import chat.rocket.android.shared.BasePresenter;
+import chat.rocket.core.interactors.RoomInteractor;
+import chat.rocket.core.models.User;
+import chat.rocket.core.repositories.UserRepository;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+
+public class SidebarMainPresenter extends BasePresenter<SidebarMainContract.View>
+    implements SidebarMainContract.Presenter {
+
+  private final String hostname;
+  private final RoomInteractor roomInteractor;
+  private final UserRepository userRepository;
+  private final MethodCallHelper methodCallHelper;
+
+  public SidebarMainPresenter(String hostname, RoomInteractor roomInteractor,
+                              UserRepository userRepository, MethodCallHelper methodCallHelper) {
+    this.hostname = hostname;
+    this.roomInteractor = roomInteractor;
+    this.userRepository = userRepository;
+    this.methodCallHelper = methodCallHelper;
+  }
+
+  @Override
+  public void bindView(@NonNull SidebarMainContract.View view) {
+    super.bindView(view);
+
+    if (TextUtils.isEmpty(hostname)) {
+      view.showEmptyScreen();
+      return;
+    }
+
+    view.showScreen();
+
+    subscribeToRooms();
+    subscribeToUser();
+  }
+
+  @Override
+  public void onUserOnline() {
+    updateCurrentUserStatus(User.STATUS_ONLINE);
+  }
+
+  @Override
+  public void onUserAway() {
+    updateCurrentUserStatus(User.STATUS_AWAY);
+  }
+
+  @Override
+  public void onUserBusy() {
+    updateCurrentUserStatus(User.STATUS_BUSY);
+  }
+
+  @Override
+  public void onUserOffline() {
+    updateCurrentUserStatus(User.STATUS_OFFLINE);
+  }
+
+  @Override
+  public void onLogout() {
+    if (methodCallHelper != null) {
+      methodCallHelper.logout().continueWith(new LogcatIfError());
+    }
+  }
+
+  private void subscribeToRooms() {
+    final Subscription subscription = roomInteractor.getOpenRooms()
+        .distinctUntilChanged()
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(
+            rooms -> view.showRoomList(rooms)
+        );
+
+    addSubscription(subscription);
+  }
+
+  private void subscribeToUser() {
+    final Subscription subscription = userRepository.getCurrent()
+        .distinctUntilChanged()
+        .subscribeOn(AndroidSchedulers.from(BackgroundLooper.get()))
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(user -> view.showUser(user));
+
+    addSubscription(subscription);
+  }
+
+  private void updateCurrentUserStatus(String status) {
+    if (methodCallHelper != null) {
+      methodCallHelper.setUserStatus(status).continueWith(new LogcatIfError());
+    }
+  }
+}

app/src/main/java/chat/rocket/android/fragment/sidebar/dialog/AbstractAddRoomDialogFragment.java

@@ -12,8 +12,8 @@ import com.trello.rxlifecycle.components.support.RxAppCompatDialogFragment;
 import bolts.Task;
 import chat.rocket.android.R;
 import chat.rocket.android.api.MethodCallHelper;
-import chat.rocket.android.realm_helper.RealmHelper;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.persistence.realm.RealmHelper;
+import chat.rocket.persistence.realm.RealmStore;
 
 public abstract class AbstractAddRoomDialogFragment extends RxAppCompatDialogFragment {
 

app/src/main/java/chat/rocket/android/fragment/sidebar/dialog/AddDirectMessageDialogFragment.java

@@ -12,11 +12,11 @@ import bolts.Task;
 import chat.rocket.android.R;
 import chat.rocket.android.helper.TextUtils;
 import chat.rocket.android.layouthelper.sidebar.dialog.SuggestUserAdapter;
-import chat.rocket.android.model.ddp.User;
-import chat.rocket.android.realm_helper.RealmAutoCompleteAdapter;
+import chat.rocket.persistence.realm.models.ddp.RealmUser;
+import chat.rocket.persistence.realm.RealmAutoCompleteAdapter;
 
 /**
- * add Direct Message.
+ * add Direct RealmMessage.
  */
 public class AddDirectMessageDialogFragment extends AbstractAddRoomDialogFragment {
   public static AddDirectMessageDialogFragment create(String hostname) {
@@ -39,10 +39,10 @@ public class AddDirectMessageDialogFragment extends AbstractAddRoomDialogFragmen
     AutoCompleteTextView autoCompleteTextView =
         (AutoCompleteTextView) getDialog().findViewById(R.id.editor_username);
 
-    RealmAutoCompleteAdapter<User> adapter = realmHelper.createAutoCompleteAdapter(getContext(),
-        (realm, text) -> realm.where(User.class)
-            .contains(User.USERNAME, text, Case.INSENSITIVE)
-            .findAllSorted(User.USERNAME),
+    RealmAutoCompleteAdapter<RealmUser> adapter = realmHelper.createAutoCompleteAdapter(getContext(),
+        (realm, text) -> realm.where(RealmUser.class)
+            .contains(RealmUser.USERNAME, text, Case.INSENSITIVE)
+            .findAllSorted(RealmUser.USERNAME),
         context -> new SuggestUserAdapter(context, hostname));
     autoCompleteTextView.setAdapter(adapter);
 

app/src/main/java/chat/rocket/android/helper/FileUploadHelper.java

@@ -14,10 +14,10 @@ import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.util.UUID;
 import chat.rocket.android.log.RCLog;
-import chat.rocket.android.model.SyncState;
-import chat.rocket.android.model.ddp.PublicSetting;
-import chat.rocket.android.model.internal.FileUploading;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.core.SyncState;
+import chat.rocket.persistence.realm.models.ddp.RealmPublicSetting;
+import chat.rocket.persistence.realm.models.internal.FileUploading;
+import chat.rocket.persistence.realm.RealmHelper;
 
 /**
  * utility class for uploading file.
@@ -59,7 +59,7 @@ public class FileUploadHelper {
                                      Uri uri, String filename, long filesize, String mimeType) {
     final String uplId = UUID.randomUUID().toString();
     final String storageType =
-        PublicSetting.getString(realmHelper, "FileUpload_Storage_Type", null);
+        RealmPublicSetting.getString(realmHelper, "FileUpload_Storage_Type", null);
 
     realmHelper.executeTransaction(realm ->
         realm.createOrUpdateObjectFromJson(FileUploading.class, new JSONObject()

app/src/main/java/chat/rocket/android/helper/GcmPushSettingHelper.java

@@ -4,28 +4,28 @@ import io.realm.Realm;
 import io.realm.RealmResults;
 
 import java.util.List;
-import chat.rocket.android.model.ddp.PublicSetting;
-import chat.rocket.android.model.ddp.PublicSettingsConstants;
+import chat.rocket.persistence.realm.models.ddp.RealmPublicSetting;
+import chat.rocket.core.PublicSettingsConstants;
 
 /**
  * utility class for getting value comprehensibly from public settings list.
  */
 public class GcmPushSettingHelper {
 
-  public static RealmResults<PublicSetting> queryForGcmPushEnabled(Realm realm) {
-    return realm.where(PublicSetting.class)
-        .equalTo(PublicSetting.ID, PublicSettingsConstants.Push.ENABLE)
+  public static RealmResults<RealmPublicSetting> queryForGcmPushEnabled(Realm realm) {
+    return realm.where(RealmPublicSetting.class)
+        .equalTo(RealmPublicSetting.ID, PublicSettingsConstants.Push.ENABLE)
         .or()
-        .equalTo(PublicSetting.ID, PublicSettingsConstants.Push.GCM_PROJECT_NUMBER)
+        .equalTo(RealmPublicSetting.ID, PublicSettingsConstants.Push.GCM_PROJECT_NUMBER)
         .findAll();
   }
 
-  public static boolean isGcmPushEnabled(List<PublicSetting> results) {
+  public static boolean isGcmPushEnabled(List<RealmPublicSetting> results) {
     return isPushEnabled(results) && hasValidGcmConfig(results);
   }
 
-  private static boolean isPushEnabled(List<PublicSetting> results) {
-    for (PublicSetting setting : results) {
+  private static boolean isPushEnabled(List<RealmPublicSetting> results) {
+    for (RealmPublicSetting setting : results) {
       if (PublicSettingsConstants.Push.ENABLE.equals(setting.getId())) {
         return "true".equals(setting.getValue());
       }
@@ -33,8 +33,8 @@ public class GcmPushSettingHelper {
     return false;
   }
 
-  private static boolean hasValidGcmConfig(List<PublicSetting> results) {
-    for (PublicSetting setting : results) {
+  private static boolean hasValidGcmConfig(List<RealmPublicSetting> results) {
+    for (RealmPublicSetting setting : results) {
       if (PublicSettingsConstants.Push.GCM_PROJECT_NUMBER.equals(setting.getId())) {
         return !TextUtils.isEmpty(setting.getValue());
       }

app/src/main/java/chat/rocket/android/layouthelper/ExtRealmModelListAdapter.java → app/src/main/java/chat/rocket/android/layouthelper/ExtModelListAdapter.java

@@ -3,21 +3,20 @@ package chat.rocket.android.layouthelper;
 import android.content.Context;
 import android.support.annotation.LayoutRes;
 import android.support.v7.util.ListUpdateCallback;
-import io.realm.RealmObject;
 
-import chat.rocket.android.realm_helper.RealmModelListAdapter;
-import chat.rocket.android.realm_helper.RealmModelViewHolder;
+import chat.rocket.android.layouthelper.chatroom.ModelListAdapter;
+import chat.rocket.android.layouthelper.chatroom.ModelViewHolder;
 
 @SuppressWarnings({"PMD.AbstractNaming", "PMD.GenericsNaming"})
 /**
- * RealmModelListAdapter with header and footer.
+ * ModelListAdapter with header and footer.
  */
-public abstract class ExtRealmModelListAdapter<T extends RealmObject, VM,
-    VH extends RealmModelViewHolder<VM>> extends RealmModelListAdapter<T, VM, VH> {
+public abstract class ExtModelListAdapter<T, VM,
+    VH extends ModelViewHolder<VM>> extends ModelListAdapter<T, VM, VH> {
   protected static final int VIEW_TYPE_HEADER = -1;
   protected static final int VIEW_TYPE_FOOTER = -2;
 
-  protected ExtRealmModelListAdapter(Context context) {
+  protected ExtModelListAdapter(Context context) {
     super(context);
   }
 

app/src/main/java/chat/rocket/android/layouthelper/chatroom/AbstractMessageViewHolder.java

@@ -7,26 +7,23 @@ import android.widget.TextView;
 import chat.rocket.android.R;
 import chat.rocket.android.helper.DateTime;
 import chat.rocket.android.helper.TextUtils;
-import chat.rocket.android.model.SyncState;
-import chat.rocket.android.realm_helper.RealmModelViewHolder;
+import chat.rocket.core.SyncState;
 import chat.rocket.android.widget.RocketChatAvatar;
 
-public abstract class AbstractMessageViewHolder extends RealmModelViewHolder<PairedMessage> {
+public abstract class AbstractMessageViewHolder extends ModelViewHolder<PairedMessage> {
   protected final RocketChatAvatar avatar;
   protected final TextView username;
   protected final TextView subUsername;
   protected final TextView timestamp;
   protected final View userAndTimeContainer;
   protected final String hostname;
-  protected final String userId;
-  protected final String token;
   protected final View newDayContainer;
   protected final TextView newDayText;
 
   /**
    * constructor WITH hostname.
    */
-  public AbstractMessageViewHolder(View itemView, String hostname, String userId, String token) {
+  public AbstractMessageViewHolder(View itemView, String hostname) {
     super(itemView);
     avatar = (RocketChatAvatar) itemView.findViewById(R.id.user_avatar);
     username = (TextView) itemView.findViewById(R.id.username);
@@ -36,8 +33,6 @@ public abstract class AbstractMessageViewHolder extends RealmModelViewHolder<Pai
     newDayContainer = itemView.findViewById(R.id.newday_container);
     newDayText = (TextView) itemView.findViewById(R.id.newday_text);
     this.hostname = hostname;
-    this.userId = userId;
-    this.token = token;
   }
 
   /**

app/src/main/java/chat/rocket/android/layouthelper/chatroom/MessageFormManager.java

 package chat.rocket.android.layouthelper.chatroom;
 
-import bolts.Task;
 import chat.rocket.android.widget.message.MessageFormLayout;
 
 /**
@@ -29,22 +28,21 @@ public class MessageFormManager {
     messageFormLayout.setText("");
   }
 
+  public void onMessageSend() {
+    clearComposingText();
+    messageFormLayout.setEnabled(true);
+  }
+
   private void sendMessage(String message) {
     if (sendMessageCallback == null) {
       return;
     }
 
     messageFormLayout.setEnabled(false);
-    sendMessageCallback.onSubmitText(message).onSuccess(task -> {
-      clearComposingText();
-      return null;
-    }).continueWith(task -> {
-      messageFormLayout.setEnabled(true);
-      return null;
-    });
+    sendMessageCallback.onSubmitText(message);
   }
 
   public interface SendMessageCallback {
-    Task<Void> onSubmitText(String messageText);
+    void onSubmitText(String messageText);
   }
 }

app/src/main/java/chat/rocket/android/layouthelper/chatroom/MessageListAdapter.java

@@ -9,30 +9,26 @@ import java.util.Collections;
 import java.util.List;
 import chat.rocket.android.R;
 import chat.rocket.android.helper.TextUtils;
-import chat.rocket.android.layouthelper.ExtRealmModelListAdapter;
-import chat.rocket.android.model.ddp.Message;
+import chat.rocket.android.layouthelper.ExtModelListAdapter;
+import chat.rocket.core.models.Message;
 
 /**
  * target list adapter for chat room.
  */
 public class MessageListAdapter
-    extends ExtRealmModelListAdapter<Message, PairedMessage, AbstractMessageViewHolder> {
+    extends ExtModelListAdapter<Message, PairedMessage, AbstractMessageViewHolder> {
 
   private static final int VIEW_TYPE_UNKNOWN = 0;
   private static final int VIEW_TYPE_NORMAL_MESSAGE = 1;
   private static final int VIEW_TYPE_SYSTEM_MESSAGE = 2;
 
   private final String hostname;
-  private final String userId;
-  private final String token;
   private boolean hasNext;
   private boolean isLoaded;
 
-  public MessageListAdapter(Context context, String hostname, String userId, String token) {
+  public MessageListAdapter(Context context, String hostname) {
     super(context);
     this.hostname = hostname;
-    this.userId = userId;
-    this.token = token;
   }
 
   /**
@@ -86,11 +82,11 @@ public class MessageListAdapter
   protected AbstractMessageViewHolder onCreateRealmModelViewHolder(int viewType, View itemView) {
     switch (viewType) {
       case VIEW_TYPE_NORMAL_MESSAGE:
-        return new MessageNormalViewHolder(itemView, hostname, userId, token);
+        return new MessageNormalViewHolder(itemView, hostname);
       case VIEW_TYPE_SYSTEM_MESSAGE:
-        return new MessageSystemViewHolder(itemView, hostname, userId, token);
+        return new MessageSystemViewHolder(itemView, hostname);
       default:
-        return new AbstractMessageViewHolder(itemView, hostname, userId, token) {
+        return new AbstractMessageViewHolder(itemView, hostname) {
           @Override
           protected void bindMessage(PairedMessage pairedMessage) {
           }

app/src/main/java/chat/rocket/android/layouthelper/chatroom/MessageNormalViewHolder.java

@@ -19,8 +19,8 @@ public class MessageNormalViewHolder extends AbstractMessageViewHolder {
   /**
    * constructor WITH hostname.
    */
-  public MessageNormalViewHolder(View itemView, String hostname, String userId, String token) {
-    super(itemView, hostname, userId, token);
+  public MessageNormalViewHolder(View itemView, String hostname) {
+    super(itemView, hostname);
     body = (RocketChatMessageLayout) itemView.findViewById(R.id.message_body);
     urls = (RocketChatMessageUrlsLayout) itemView.findViewById(R.id.message_urls);
     attachments =
@@ -35,6 +35,6 @@ public class MessageNormalViewHolder extends AbstractMessageViewHolder {
         .timestampInto(timestamp)
         .bodyInto(body)
         .urlsInto(urls)
-        .attachmentsInto(attachments, hostname, userId, token);
+        .attachmentsInto(attachments, hostname);
   }
 }

app/src/main/java/chat/rocket/android/layouthelper/chatroom/MessageSystemViewHolder.java

@@ -15,8 +15,8 @@ public class MessageSystemViewHolder extends AbstractMessageViewHolder {
   /**
    * constructor WITH hostname.
    */
-  public MessageSystemViewHolder(View itemView, String hostname, String userId, String token) {
-    super(itemView, hostname, userId, token);
+  public MessageSystemViewHolder(View itemView, String hostname) {
+    super(itemView, hostname);
     body = (TextView) itemView.findViewById(R.id.message_body);
   }
 

app/src/main/java/chat/rocket/android/layouthelper/chatroom/MessageType.java

@@ -3,7 +3,7 @@ package chat.rocket.android.layouthelper.chatroom;
 import android.content.Context;
 
 import chat.rocket.android.R;
-import chat.rocket.android.model.ddp.Message;
+import chat.rocket.core.models.Message;
 
 /**
  * message type.
@@ -69,7 +69,9 @@ public enum MessageType {
 
   public static MessageType parse(String value) {
     for (MessageType type : MessageType.values()) {
-      if (type.value.equals(value)) return type;
+      if (type.value.equals(value)) {
+        return type;
+      }
     }
     return UNSPECIFIED;
   }

realm-helpers/src/main/java/chat/rocket/android/realm_helper/RealmModelListAdapter.java → app/src/main/java/chat/rocket/android/layouthelper/chatroom/ModelListAdapter.java

-package chat.rocket.android.realm_helper;
+package chat.rocket.android.layouthelper.chatroom;
 
 import android.content.Context;
 import android.support.annotation.LayoutRes;
@@ -8,46 +8,25 @@ import android.support.v7.widget.RecyclerView;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
-import io.realm.RealmObject;
 
 import java.util.List;
 
-public abstract class RealmModelListAdapter<T extends RealmObject, VM,
-    VH extends RealmModelViewHolder<VM>> extends RecyclerView.Adapter<VH> {
+@SuppressWarnings("PMD.GenericsNaming")
+public abstract class ModelListAdapter<T, VM, VH extends ModelViewHolder<VM>>
+    extends RecyclerView.Adapter<VH> {
 
   protected final LayoutInflater inflater;
-  private RealmListObserver<T> realmListObserver;
   private List<VM> adapterData;
   private OnItemClickListener<VM> onItemClickListener;
 
-  protected RealmModelListAdapter(Context context) {
+  protected ModelListAdapter(Context context) {
     this.inflater = LayoutInflater.from(context);
   }
 
-  /*package*/ RealmModelListAdapter<T, VM, VH> initializeWith(final RealmHelper realmHelper,
-                                                              RealmListObserver.Query<T> query) {
-    realmListObserver = new RealmListObserver<>(realmHelper, query)
-        .setOnUpdateListener(results -> updateData(realmHelper.copyFromRealm(results)));
-    return this;
-  }
-
-  @Override
-  public void onAttachedToRecyclerView(RecyclerView recyclerView) {
-    super.onAttachedToRecyclerView(recyclerView);
-    realmListObserver.sub();
-  }
-
-  @Override
-  public void onDetachedFromRecyclerView(RecyclerView recyclerView) {
-    realmListObserver.unsub();
-    super.onDetachedFromRecyclerView(recyclerView);
-  }
-
   protected abstract int getRealmModelViewType(VM model);
 
-  protected abstract
   @LayoutRes
-  int getLayout(int viewType);
+  protected abstract int getLayout(int viewType);
 
   protected abstract VH onCreateRealmModelViewHolder(int viewType, View itemView);
 
@@ -86,7 +65,7 @@ public abstract class RealmModelListAdapter<T extends RealmObject, VM,
     return adapterData.get(position);
   }
 
-  private void updateData(List<T> newData) {
+  public void updateData(List<T> newData) {
     if (adapterData == null) {
       adapterData = mapResultsToViewModel(newData);
       notifyDataSetChanged();
@@ -133,8 +112,8 @@ public abstract class RealmModelListAdapter<T extends RealmObject, VM,
     this.onItemClickListener = onItemClickListener;
   }
 
-  public interface Constructor<T extends RealmObject, VM, VH extends RealmModelViewHolder<VM>> {
-    RealmModelListAdapter<T, VM, VH> getNewInstance(Context context);
+  public interface Constructor<T, VM, VH extends ModelViewHolder<VM>> {
+    ModelListAdapter<T, VM, VH> getNewInstance(Context context);
   }
 
   public interface OnItemClickListener<VM> {

realm-helpers/src/main/java/chat/rocket/android/realm_helper/RealmModelViewHolder.java → app/src/main/java/chat/rocket/android/layouthelper/chatroom/ModelViewHolder.java

-package chat.rocket.android.realm_helper;
+package chat.rocket.android.layouthelper.chatroom;
 
 import android.support.v7.widget.RecyclerView;
 import android.view.View;
 
-public abstract class RealmModelViewHolder<T> extends RecyclerView.ViewHolder {
+public abstract class ModelViewHolder<T> extends RecyclerView.ViewHolder {
 
-  public RealmModelViewHolder(View itemView) {
+  public ModelViewHolder(View itemView) {
     super(itemView);
   }
 

app/src/main/java/chat/rocket/android/layouthelper/chatroom/PairedMessage.java

 package chat.rocket.android.layouthelper.chatroom;
 
 import chat.rocket.android.helper.DateTime;
-import chat.rocket.android.model.ddp.Message;
+import chat.rocket.core.models.Message;
 
 /**
  * ViewData Model for messages in chatroom.

app/src/main/java/chat/rocket/android/layouthelper/chatroom/RoomListManager.java

@@ -4,7 +4,7 @@ import android.view.View;
 import android.view.ViewGroup;
 
 import chat.rocket.android.helper.TextUtils;
-import chat.rocket.android.model.ddp.RoomSubscription;
+import chat.rocket.core.models.Room;
 import chat.rocket.android.widget.internal.RoomListItemView;
 import java.util.List;
 
@@ -19,7 +19,7 @@ public class RoomListManager {
 
   private boolean unreadRoomMode = false;
 
-  private List<RoomSubscription> roomSubscriptionList;
+  private List<Room> roomList;
 
   /**
    * Callback interface for List item clicked.
@@ -54,8 +54,8 @@ public class RoomListManager {
   /**
    * update ViewGroups with room list.
    */
-  public void setRooms(List<RoomSubscription> roomSubscriptionList) {
-    this.roomSubscriptionList = roomSubscriptionList;
+  public void setRooms(List<Room> roomList) {
+    this.roomList = roomList;
     updateRoomsList();
   }
 
@@ -66,14 +66,14 @@ public class RoomListManager {
     this.listener = listener;
   }
 
-  private void removeDeletedItem(ViewGroup parent, List<RoomSubscription> roomSubscriptionList) {
+  private void removeDeletedItem(ViewGroup parent, List<Room> roomList) {
     for (int index = parent.getChildCount() - 1; index >= 0; index--) {
       RoomListItemView roomListItemView = (RoomListItemView) parent.getChildAt(index);
       final String targetRoomName = roomListItemView.getRoomName();
       if (!TextUtils.isEmpty(targetRoomName)) {
         boolean found = false;
-        for (RoomSubscription roomSubscription : roomSubscriptionList) {
-          if (targetRoomName.equals(roomSubscription.getName())) {
+        for (Room room : roomList) {
+          if (targetRoomName.equals(room.getName())) {
             found = true;
             break;
           }
@@ -90,15 +90,15 @@ public class RoomListManager {
     updateRoomsList();
   }
 
-  private void insertOrUpdateItem(ViewGroup parent, RoomSubscription roomSubscription) {
-    final String roomName = roomSubscription.getName();
+  private void insertOrUpdateItem(ViewGroup parent, Room room) {
+    final String roomName = room.getName();
 
     int index;
     for (index = 0; index < parent.getChildCount(); index++) {
       RoomListItemView roomListItemView = (RoomListItemView) parent.getChildAt(index);
       final String targetRoomName = roomListItemView.getRoomName();
       if (roomName.equals(targetRoomName)) {
-        updateRoomItemView(roomListItemView, roomSubscription);
+        updateRoomItemView(roomListItemView, room);
         return;
       }
       if (roomName.compareToIgnoreCase(targetRoomName) < 0) {
@@ -107,7 +107,7 @@ public class RoomListManager {
     }
 
     RoomListItemView roomListItemView = new RoomListItemView(parent.getContext());
-    updateRoomItemView(roomListItemView, roomSubscription);
+    updateRoomItemView(roomListItemView, room);
     if (index == parent.getChildCount()) {
       parent.addView(roomListItemView);
     } else {
@@ -116,13 +116,13 @@ public class RoomListManager {
   }
 
   private void updateRoomItemView(RoomListItemView roomListItemView,
-                                  RoomSubscription roomSubscription) {
+                                  Room room) {
     roomListItemView
-        .setRoomId(roomSubscription.getRoomId())
-        .setRoomName(roomSubscription.getName())
-        .setRoomType(roomSubscription.getType())
-        .setAlert(roomSubscription.isAlert())
-        .setUnreadCount(roomSubscription.getUnread());
+        .setRoomId(room.getRoomId())
+        .setRoomName(room.getName())
+        .setRoomType(room.getType())
+        .setAlert(room.isAlert())
+        .setUnreadCount(room.getUnread());
 
     roomListItemView.setOnClickListener(this::onItemClick);
   }
@@ -134,31 +134,35 @@ public class RoomListManager {
   }
 
   private void updateRoomsList() {
-    removeDeletedItem(unreadRoomsContainer, roomSubscriptionList);
-    removeDeletedItem(channelsContainer, roomSubscriptionList);
-    removeDeletedItem(dmContainer, roomSubscriptionList);
+    if (roomList == null) {
+      return;
+    }
+
+    removeDeletedItem(unreadRoomsContainer, roomList);
+    removeDeletedItem(channelsContainer, roomList);
+    removeDeletedItem(dmContainer, roomList);
 
-    for (RoomSubscription roomSubscription : roomSubscriptionList) {
-      String name = roomSubscription.getName();
+    for (Room room : roomList) {
+      String name = room.getName();
       if (TextUtils.isEmpty(name)) {
         continue;
       }
 
-      String type = roomSubscription.getType();
+      String type = room.getType();
 
-      if (unreadRoomMode && roomSubscription.isAlert()) {
-        insertOrUpdateItem(unreadRoomsContainer, roomSubscription);
+      if (unreadRoomMode && room.isAlert()) {
+        insertOrUpdateItem(unreadRoomsContainer, room);
         removeItemIfExists(channelsContainer, name);
         removeItemIfExists(dmContainer, name);
-      } else if (RoomSubscription.TYPE_CHANNEL.equals(type)
-          || RoomSubscription.TYPE_PRIVATE.equals(type)) {
+      } else if (Room.TYPE_CHANNEL.equals(type)
+          || Room.TYPE_PRIVATE.equals(type)) {
         removeItemIfExists(unreadRoomsContainer, name);
-        insertOrUpdateItem(channelsContainer, roomSubscription);
+        insertOrUpdateItem(channelsContainer, room);
         removeItemIfExists(dmContainer, name);
-      } else if (RoomSubscription.TYPE_DIRECT_MESSAGE.equals(type)) {
+      } else if (Room.TYPE_DIRECT_MESSAGE.equals(type)) {
         removeItemIfExists(unreadRoomsContainer, name);
         removeItemIfExists(channelsContainer, name);
-        insertOrUpdateItem(dmContainer, roomSubscription);
+        insertOrUpdateItem(dmContainer, room);
       }
     }
 

app/src/main/java/chat/rocket/android/layouthelper/chatroom/dialog/RoomUserAdapter.java

@@ -9,8 +9,8 @@ import android.view.ViewGroup;
 import java.util.List;
 import chat.rocket.android.R;
 import chat.rocket.android.helper.TextUtils;
-import chat.rocket.android.model.ddp.User;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.models.ddp.RealmUser;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.renderer.UserRenderer;
 
 /**
@@ -47,16 +47,16 @@ public class RoomUserAdapter extends RecyclerView.Adapter<RoomUserViewHolder> {
       return;
     }
 
-    User user = realmHelper.executeTransactionForRead(realm ->
-        realm.where(User.class).equalTo(User.USERNAME, username).findFirst());
+    RealmUser user = realmHelper.executeTransactionForRead(realm ->
+        realm.where(RealmUser.class).equalTo(RealmUser.USERNAME, username).findFirst());
     if (user == null) {
-      user = new User();
+      user = new RealmUser();
       user.setUsername(username);
-      new UserRenderer(context, user)
+      new UserRenderer(context, user.asUser())
           .avatarInto(holder.avatar, hostname)
           .usernameInto(holder.username);
     } else {
-      new UserRenderer(context, user)
+      new UserRenderer(context, user.asUser())
           .statusColorInto(holder.status)
           .avatarInto(holder.avatar, hostname)
           .usernameInto(holder.username);

app/src/main/java/chat/rocket/android/layouthelper/sidebar/dialog/SuggestUserAdapter.java

@@ -7,15 +7,15 @@ import android.widget.ImageView;
 import java.util.Iterator;
 import java.util.List;
 import chat.rocket.android.R;
-import chat.rocket.android.model.ddp.User;
-import chat.rocket.android.realm_helper.RealmAutoCompleteAdapter;
+import chat.rocket.persistence.realm.models.ddp.RealmUser;
+import chat.rocket.persistence.realm.RealmAutoCompleteAdapter;
 import chat.rocket.android.renderer.UserRenderer;
 import chat.rocket.android.widget.RocketChatAvatar;
 
 /**
  * adapter to suggest user names.
  */
-public class SuggestUserAdapter extends RealmAutoCompleteAdapter<User> {
+public class SuggestUserAdapter extends RealmAutoCompleteAdapter<RealmUser> {
   private final String hostname;
 
   public SuggestUserAdapter(Context context, String hostname) {
@@ -24,18 +24,18 @@ public class SuggestUserAdapter extends RealmAutoCompleteAdapter<User> {
   }
 
   @Override
-  protected void onBindItemView(View itemView, User user) {
-    new UserRenderer(itemView.getContext(), user)
+  protected void onBindItemView(View itemView, RealmUser user) {
+    new UserRenderer(itemView.getContext(), user.asUser())
         .statusColorInto((ImageView) itemView.findViewById(R.id.room_user_status))
         .avatarInto((RocketChatAvatar) itemView.findViewById(R.id.room_user_avatar), hostname);
   }
 
   @Override
-  protected void filterList(List<User> users, String text) {
-    Iterator<User> itUsers = users.iterator();
+  protected void filterList(List<RealmUser> users, String text) {
+    Iterator<RealmUser> itUsers = users.iterator();
     final String prefix = text.toLowerCase();
     while (itUsers.hasNext()) {
-      User user = itUsers.next();
+      RealmUser user = itUsers.next();
       if (!user.getUsername().toLowerCase().startsWith(prefix)) {
         itUsers.remove();
       }
@@ -43,7 +43,7 @@ public class SuggestUserAdapter extends RealmAutoCompleteAdapter<User> {
   }
 
   @Override
-  protected String getStringForSelectedItem(User user) {
+  protected String getStringForSelectedItem(RealmUser user) {
     return user.getUsername();
   }
 }

app/src/main/java/chat/rocket/android/push/PushNotificationHandler.java

@@ -34,7 +34,7 @@ import java.util.Random;
 import chat.rocket.android.activity.MainActivity;
 import chat.rocket.android.helper.ServerPolicyHelper;
 import chat.rocket.android.service.ConnectivityManager;
-import chat.rocket.android.service.ServerInfo;
+import chat.rocket.core.models.ServerInfo;
 
 public class PushNotificationHandler implements PushConstants {
 
@@ -661,7 +661,7 @@ public class PushNotificationHandler implements PushConstants {
         ConnectivityManager.getInstance(context.getApplicationContext()).getServerList();
 
     for (ServerInfo serverInfo : serverInfoList) {
-      if (serverInfo.hostname.equals(hostname)) {
+      if (serverInfo.getHostname().equals(hostname)) {
         return true;
       }
     }

app/src/main/java/chat/rocket/android/push/gcm/GcmInstanceIDListenerService.java

@@ -4,12 +4,12 @@ import com.google.android.gms.iid.InstanceIDListenerService;
 
 import java.util.List;
 import chat.rocket.android.helper.GcmPushSettingHelper;
-import chat.rocket.android.model.ddp.PublicSetting;
-import chat.rocket.android.model.internal.GcmPushRegistration;
-import chat.rocket.android.realm_helper.RealmHelper;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.persistence.realm.models.ddp.RealmPublicSetting;
+import chat.rocket.persistence.realm.models.internal.GcmPushRegistration;
+import chat.rocket.persistence.realm.RealmHelper;
+import chat.rocket.persistence.realm.RealmStore;
 import chat.rocket.android.service.ConnectivityManager;
-import chat.rocket.android.service.ServerInfo;
+import chat.rocket.core.models.ServerInfo;
 
 public class GcmInstanceIDListenerService extends InstanceIDListenerService {
 
@@ -18,7 +18,7 @@ public class GcmInstanceIDListenerService extends InstanceIDListenerService {
     List<ServerInfo> serverInfoList = ConnectivityManager.getInstance(getApplicationContext())
         .getServerList();
     for (ServerInfo serverInfo : serverInfoList) {
-      RealmHelper realmHelper = RealmStore.get(serverInfo.hostname);
+      RealmHelper realmHelper = RealmStore.get(serverInfo.getHostname());
       if (realmHelper != null) {
         updateGcmToken(realmHelper);
       }
@@ -26,7 +26,7 @@ public class GcmInstanceIDListenerService extends InstanceIDListenerService {
   }
 
   private void updateGcmToken(RealmHelper realmHelper) {
-    final List<PublicSetting> results = realmHelper.executeTransactionForReadResults(
+    final List<RealmPublicSetting> results = realmHelper.executeTransactionForReadResults(
         GcmPushSettingHelper::queryForGcmPushEnabled);
     final boolean gcmPushEnabled = GcmPushSettingHelper.isGcmPushEnabled(results);
 

app/src/main/java/chat/rocket/android/renderer/FileUploadingRenderer.java

@@ -4,7 +4,7 @@ import android.content.Context;
 import android.widget.ProgressBar;
 import android.widget.TextView;
 
-import chat.rocket.android.model.internal.FileUploading;
+import chat.rocket.persistence.realm.models.internal.FileUploading;
 
 /**
  * rendering FileUploading status.

app/src/main/java/chat/rocket/android/renderer/MessageRenderer.java

@@ -5,20 +5,23 @@ import android.support.graphics.drawable.VectorDrawableCompat;
 import android.view.View;
 import android.widget.TextView;
 
+import java.util.List;
 import chat.rocket.android.R;
 import chat.rocket.android.helper.Avatar;
 import chat.rocket.android.helper.DateTime;
 import chat.rocket.android.helper.TextUtils;
-import chat.rocket.android.model.SyncState;
-import chat.rocket.android.model.ddp.Message;
-import chat.rocket.android.model.ddp.User;
+import chat.rocket.core.SyncState;
+import chat.rocket.core.models.Attachment;
+import chat.rocket.core.models.Message;
 import chat.rocket.android.widget.RocketChatAvatar;
 import chat.rocket.android.widget.message.RocketChatMessageAttachmentsLayout;
 import chat.rocket.android.widget.message.RocketChatMessageLayout;
 import chat.rocket.android.widget.message.RocketChatMessageUrlsLayout;
+import chat.rocket.core.models.User;
+import chat.rocket.core.models.WebContent;
 
 /**
- * Renderer for Message model.
+ * Renderer for RealmMessage model.
  */
 public class MessageRenderer extends AbstractRenderer<Message> {
 
@@ -103,12 +106,12 @@ public class MessageRenderer extends AbstractRenderer<Message> {
       return this;
     }
 
-    String urls = object.getUrls();
-    if (TextUtils.isEmpty(urls)) {
+    List<WebContent> webContents = object.getWebContents();
+    if (webContents == null || webContents.size() == 0) {
       urlsLayout.setVisibility(View.GONE);
     } else {
       urlsLayout.setVisibility(View.VISIBLE);
-      urlsLayout.setUrls(urls);
+      urlsLayout.setUrls(webContents);
     }
 
     return this;
@@ -118,13 +121,13 @@ public class MessageRenderer extends AbstractRenderer<Message> {
    * show urls in RocketChatMessageUrlsLayout.
    */
   public MessageRenderer attachmentsInto(RocketChatMessageAttachmentsLayout attachmentsLayout,
-                                         String hostname, String userId, String token) {
+                                         String hostname) {
     if (!shouldHandle(attachmentsLayout)) {
       return this;
     }
 
-    String attachments = object.getAttachments();
-    if (TextUtils.isEmpty(attachments)) {
+    List<Attachment> attachments = object.getAttachments();
+    if (attachments == null || attachments.size() == 0) {
       attachmentsLayout.setVisibility(View.GONE);
     } else {
       attachmentsLayout.setVisibility(View.VISIBLE);

app/src/main/java/chat/rocket/android/renderer/UserRenderer.java

@@ -7,11 +7,11 @@ import android.widget.TextView;
 import chat.rocket.android.R;
 import chat.rocket.android.helper.Avatar;
 import chat.rocket.android.helper.TextUtils;
-import chat.rocket.android.model.ddp.User;
+import chat.rocket.core.models.User;
 import chat.rocket.android.widget.RocketChatAvatar;
 
 /**
- * Renderer for User model.
+ * Renderer for RealmUser model.
  */
 public class UserRenderer extends AbstractRenderer<User> {
 

app/src/main/java/chat/rocket/android/service/ConnectivityManagerApi.java

@@ -3,6 +3,7 @@ package chat.rocket.android.service;
 import android.support.annotation.Nullable;
 
 import java.util.List;
+import chat.rocket.core.models.ServerInfo;
 import rx.Observable;
 import rx.Single;
 

app/src/main/java/chat/rocket/android/service/ConnectivityManagerInternal.java

 package chat.rocket.android.service;
 
 import java.util.List;
+import chat.rocket.core.models.ServerInfo;
 
 /**
  * interfaces used for RocketChatService and RocketChatwebSocketThread.

app/src/main/java/chat/rocket/android/service/RealmBasedConnectivityManager.java

@@ -13,6 +13,8 @@ import java.util.Map;
 import java.util.concurrent.TimeUnit;
 import chat.rocket.android.helper.RxHelper;
 import chat.rocket.android.log.RCLog;
+import chat.rocket.core.models.ServerInfo;
+import chat.rocket.persistence.realm.models.RealmBasedServerInfo;
 import hugo.weaving.DebugLog;
 import rx.Observable;
 import rx.Single;
@@ -41,7 +43,7 @@ import rx.subjects.PublishSubject;
 
 
   /*package*/ RealmBasedConnectivityManager setContext(Context appContext) {
-    this.appContext = appContext;
+    this.appContext = appContext.getApplicationContext();
     return this;
   }
 
@@ -49,7 +51,7 @@ import rx.subjects.PublishSubject;
   public void resetConnectivityStateList() {
     serverConnectivityList.clear();
     for (ServerInfo serverInfo : RealmBasedServerInfo.getServerInfoList()) {
-      serverConnectivityList.put(serverInfo.hostname, ServerConnectivity.STATE_DISCONNECTED);
+      serverConnectivityList.put(serverInfo.getHostname(), ServerConnectivity.STATE_DISCONNECTED);
     }
   }
 
@@ -65,7 +67,8 @@ import rx.subjects.PublishSubject;
   public void ensureConnections() {
     for (String hostname : serverConnectivityList.keySet()) {
       connectToServerIfNeeded(hostname, true/* force connect */)
-          .subscribe(_val -> { }, RCLog::e);
+          .subscribe(_val -> {
+          }, RCLog::e);
     }
   }
 
@@ -77,7 +80,8 @@ import rx.subjects.PublishSubject;
       serverConnectivityList.put(hostname, ServerConnectivity.STATE_DISCONNECTED);
     }
     connectToServerIfNeeded(hostname, false)
-        .subscribe(_val -> { }, RCLog::e);
+        .subscribe(_val -> {
+        }, RCLog::e);
   }
 
   @Override
@@ -85,7 +89,8 @@ import rx.subjects.PublishSubject;
     RealmBasedServerInfo.remove(hostname);
     if (serverConnectivityList.containsKey(hostname)) {
       disconnectFromServerIfNeeded(hostname)
-          .subscribe(_val -> { }, RCLog::e);
+          .subscribe(_val -> {
+          }, RCLog::e);
     }
   }
 
@@ -185,7 +190,8 @@ import rx.subjects.PublishSubject;
         .filter(serverConnectivity -> hostname.equals(serverConnectivity.hostname))
         .map(serverConnectivity -> serverConnectivity.state)
         .filter(state ->
-            state == ServerConnectivity.STATE_CONNECTED || state == ServerConnectivity.STATE_DISCONNECTED)
+            state == ServerConnectivity.STATE_CONNECTED
+                || state == ServerConnectivity.STATE_DISCONNECTED)
         .first()
         .toSingle()
         .flatMap(state ->

app/src/main/java/chat/rocket/android/service/RocketChatWebSocketThread.java

@@ -14,9 +14,10 @@ import chat.rocket.android.api.MethodCallHelper;
 import chat.rocket.android.helper.LogcatIfError;
 import chat.rocket.android.helper.TextUtils;
 import chat.rocket.android.log.RCLog;
-import chat.rocket.android.model.internal.Session;
-import chat.rocket.android.realm_helper.RealmHelper;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.core.models.ServerInfo;
+import chat.rocket.persistence.realm.models.internal.RealmSession;
+import chat.rocket.persistence.realm.RealmHelper;
+import chat.rocket.persistence.realm.RealmStore;
 import chat.rocket.android.service.ddp.base.ActiveUsersSubscriber;
 import chat.rocket.android.service.ddp.base.LoginServiceConfigurationSubscriber;
 import chat.rocket.android.service.ddp.base.UserDataSubscriber;
@@ -126,7 +127,7 @@ public class RocketChatWebSocketThread extends HandlerThread {
 
   private void forceInvalidateTokens() {
     realmHelper.executeTransaction(realm -> {
-      Session session = Session.queryDefaultSession(realm).findFirst();
+      RealmSession session = RealmSession.queryDefaultSession(realm).findFirst();
       if (session != null
           && !TextUtils.isEmpty(session.getToken())
           && (session.isTokenVerified() || !TextUtils.isEmpty(session.getError()))) {
@@ -225,7 +226,7 @@ public class RocketChatWebSocketThread extends HandlerThread {
         .flatMap(_val -> Single.fromEmitter(emitter -> {
           ServerInfo info = connectivityManager.getServerInfoForHost(hostname);
           RCLog.d("DDPClient#connect");
-          ddpClient.connect(info.session, !info.insecure)
+          ddpClient.connect(info.getSession(), info.isSecure())
               .onSuccessTask(task -> {
                 final String newSession = task.getResult().session;
                 connectivityManager.notifyConnectionEstablished(hostname, newSession);
@@ -239,10 +240,10 @@ public class RocketChatWebSocketThread extends HandlerThread {
                 });
 
                 return realmHelper.executeTransaction(realm -> {
-                  Session sessionObj = Session.queryDefaultSession(realm).findFirst();
+                  RealmSession sessionObj = RealmSession.queryDefaultSession(realm).findFirst();
                   if (sessionObj == null) {
-                    realm.createOrUpdateObjectFromJson(Session.class,
-                        new JSONObject().put(Session.ID, Session.DEFAULT_ID));
+                    realm.createOrUpdateObjectFromJson(RealmSession.class,
+                        new JSONObject().put(RealmSession.ID, RealmSession.DEFAULT_ID));
                   } else {
                     // invalidate login token.
                     if (!TextUtils.isEmpty(sessionObj.getToken()) && sessionObj.isTokenVerified()) {

app/src/main/java/chat/rocket/android/service/ServerInfo.java

-package chat.rocket.android.service;
-
-
-/**
- * Stores information just for required for initializing connectivity manager.
- */
-public class ServerInfo {
-  public final String hostname;
-  public final String name;
-  /*package*/ final String session;
-  public final boolean insecure;
-
-  public ServerInfo(String hostname, String name, String session, boolean insecure) {
-    this.hostname = hostname;
-    this.name = name;
-    this.session = session;
-    this.insecure = insecure;
-  }
-}

app/src/main/java/chat/rocket/android/service/ddp/AbstractDDPDocEventSubscriber.java

@@ -11,7 +11,7 @@ import org.json.JSONObject;
 import java.util.Iterator;
 import chat.rocket.android.helper.LogcatIfError;
 import chat.rocket.android.log.RCLog;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 import chat.rocket.android.service.Registrable;
 import chat.rocket.android_ddp.DDPSubscription;

app/src/main/java/chat/rocket/android/service/ddp/base/AbstractBaseSubscriber.java

@@ -3,7 +3,7 @@ package chat.rocket.android.service.ddp.base;
 import android.content.Context;
 import org.json.JSONArray;
 
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 import chat.rocket.android.service.ddp.AbstractDDPDocEventSubscriber;
 

app/src/main/java/chat/rocket/android/service/ddp/base/ActiveUsersSubscriber.java

@@ -5,8 +5,8 @@ import io.realm.RealmObject;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-import chat.rocket.android.model.ddp.User;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.models.ddp.RealmUser;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
 /**
@@ -30,7 +30,7 @@ public class ActiveUsersSubscriber extends AbstractBaseSubscriber {
 
   @Override
   protected Class<? extends RealmObject> getModelClass() {
-    return User.class;
+    return RealmUser.class;
   }
 
   @Override

app/src/main/java/chat/rocket/android/service/ddp/base/LoginServiceConfigurationSubscriber.java

@@ -3,8 +3,8 @@ package chat.rocket.android.service.ddp.base;
 import android.content.Context;
 import io.realm.RealmObject;
 
-import chat.rocket.android.model.ddp.MeteorLoginServiceConfiguration;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.models.ddp.RealmMeteorLoginServiceConfiguration;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
 /**
@@ -28,6 +28,6 @@ public class LoginServiceConfigurationSubscriber extends AbstractBaseSubscriber
 
   @Override
   protected Class<? extends RealmObject> getModelClass() {
-    return MeteorLoginServiceConfiguration.class;
+    return RealmMeteorLoginServiceConfiguration.class;
   }
 }

app/src/main/java/chat/rocket/android/service/ddp/base/UserDataSubscriber.java

@@ -5,8 +5,8 @@ import io.realm.RealmObject;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-import chat.rocket.android.model.ddp.User;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.models.ddp.RealmUser;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
 /**
@@ -30,7 +30,7 @@ public class UserDataSubscriber extends AbstractBaseSubscriber {
 
   @Override
   protected Class<? extends RealmObject> getModelClass() {
-    return User.class;
+    return RealmUser.class;
   }
 
   @Override

app/src/main/java/chat/rocket/android/service/ddp/stream/AbstractStreamNotifyEventSubscriber.java

@@ -7,7 +7,7 @@ import org.json.JSONObject;
 
 import chat.rocket.android.helper.LogcatIfError;
 import chat.rocket.android.log.RCLog;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 import chat.rocket.android.service.ddp.AbstractDDPDocEventSubscriber;
 import chat.rocket.android_ddp.DDPSubscription;

app/src/main/java/chat/rocket/android/service/ddp/stream/AbstractStreamNotifyUserEventSubscriber.java

@@ -2,7 +2,7 @@ package chat.rocket.android.service.ddp.stream;
 
 import android.content.Context;
 
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
 abstract class AbstractStreamNotifyUserEventSubscriber extends AbstractStreamNotifyEventSubscriber {

app/src/main/java/chat/rocket/android/service/ddp/stream/StreamNotifyUserSubscriptionsChanged.java

@@ -5,8 +5,8 @@ import io.realm.RealmObject;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-import chat.rocket.android.model.ddp.RoomSubscription;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.models.ddp.RealmRoom;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
 public class StreamNotifyUserSubscriptionsChanged extends AbstractStreamNotifyUserEventSubscriber {
@@ -23,12 +23,12 @@ public class StreamNotifyUserSubscriptionsChanged extends AbstractStreamNotifyUs
 
   @Override
   protected Class<? extends RealmObject> getModelClass() {
-    return RoomSubscription.class;
+    return RealmRoom.class;
   }
 
   @Override
   protected JSONObject customizeFieldJson(JSONObject json) throws JSONException {
-    return RoomSubscription.customizeJson(super.customizeFieldJson(json));
+    return RealmRoom.customizeJson(super.customizeFieldJson(json));
   }
 
   @Override

app/src/main/java/chat/rocket/android/service/ddp/stream/StreamRoomMessage.java

@@ -5,8 +5,8 @@ import io.realm.RealmObject;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-import chat.rocket.android.model.ddp.Message;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.models.ddp.RealmMessage;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
 /**
@@ -33,7 +33,7 @@ public class StreamRoomMessage extends AbstractStreamNotifyEventSubscriber {
 
   @Override
   protected Class<? extends RealmObject> getModelClass() {
-    return Message.class;
+    return RealmMessage.class;
   }
 
   @Override
@@ -43,6 +43,6 @@ public class StreamRoomMessage extends AbstractStreamNotifyEventSubscriber {
 
   @Override
   protected JSONObject customizeFieldJson(JSONObject json) throws JSONException {
-    return Message.customizeJson(super.customizeFieldJson(json));
+    return RealmMessage.customizeJson(super.customizeFieldJson(json));
   }
 }

app/src/main/java/chat/rocket/android/service/internal/AbstractRocketChatCacheObserver.java

@@ -5,8 +5,8 @@ import android.content.SharedPreferences;
 
 import chat.rocket.android.RocketChatCache;
 import chat.rocket.android.helper.TextUtils;
-import chat.rocket.android.model.ddp.RoomSubscription;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.models.ddp.RealmRoom;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.Registrable;
 
 public abstract class AbstractRocketChatCacheObserver implements Registrable {
@@ -28,8 +28,8 @@ public abstract class AbstractRocketChatCacheObserver implements Registrable {
   private void updateRoomIdWith(SharedPreferences prefs) {
     String roomId = prefs.getString(RocketChatCache.KEY_SELECTED_ROOM_ID, null);
     if (!TextUtils.isEmpty(roomId)) {
-      RoomSubscription room = realmHelper.executeTransactionForRead(realm ->
-          realm.where(RoomSubscription.class).equalTo("rid", roomId).findFirst());
+      RealmRoom room = realmHelper.executeTransactionForRead(realm ->
+          realm.where(RealmRoom.class).equalTo("rid", roomId).findFirst());
       if (room != null) {
         if (this.roomId == null || !this.roomId.equals(roomId)) {
           this.roomId = roomId;

app/src/main/java/chat/rocket/android/service/internal/StreamRoomMessageManager.java

@@ -4,7 +4,7 @@ import android.content.Context;
 import android.os.Handler;
 import android.os.Looper;
 
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 import chat.rocket.android.service.Registrable;
 import chat.rocket.android.service.ddp.stream.StreamRoomMessage;

app/src/main/java/chat/rocket/android/service/observer/AbstractModelObserver.java

@@ -3,8 +3,8 @@ package chat.rocket.android.service.observer;
 import android.content.Context;
 import io.realm.RealmObject;
 
-import chat.rocket.android.realm_helper.RealmHelper;
-import chat.rocket.android.realm_helper.RealmListObserver;
+import chat.rocket.persistence.realm.RealmHelper;
+import chat.rocket.persistence.realm.RealmListObserver;
 import chat.rocket.android.service.DDPClientRef;
 import chat.rocket.android.service.Registrable;
 

app/src/main/java/chat/rocket/android/service/observer/CurrentUserObserver.java

@@ -8,8 +8,8 @@ import java.util.ArrayList;
 import java.util.List;
 import chat.rocket.android.api.MethodCallHelper;
 import chat.rocket.android.helper.LogcatIfError;
-import chat.rocket.android.model.ddp.User;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.models.ddp.RealmUser;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 import chat.rocket.android.service.Registrable;
 import chat.rocket.android.service.ddp.stream.StreamNotifyUserSubscriptionsChanged;
@@ -18,7 +18,7 @@ import hugo.weaving.DebugLog;
 /**
  * observe the user with emails.
  */
-public class CurrentUserObserver extends AbstractModelObserver<User> {
+public class CurrentUserObserver extends AbstractModelObserver<RealmUser> {
   private final MethodCallHelper methodCall;
   private boolean currentUserExists;
   private ArrayList<Registrable> listeners;
@@ -31,12 +31,12 @@ public class CurrentUserObserver extends AbstractModelObserver<User> {
   }
 
   @Override
-  public RealmResults<User> queryItems(Realm realm) {
-    return User.queryCurrentUser(realm).findAll();
+  public RealmResults<RealmUser> queryItems(Realm realm) {
+    return RealmUser.queryCurrentUser(realm).findAll();
   }
 
   @Override
-  public void onUpdateResults(List<User> results) {
+  public void onUpdateResults(List<RealmUser> results) {
     boolean exists = !results.isEmpty();
 
     if (currentUserExists != exists) {
@@ -50,7 +50,7 @@ public class CurrentUserObserver extends AbstractModelObserver<User> {
   }
 
   @DebugLog
-  private void onLogin(User user) {
+  private void onLogin(RealmUser user) {
     if (listeners != null) {
       onLogout();
     }

app/src/main/java/chat/rocket/android/service/observer/FileUploadingToS3Observer.java

@@ -15,9 +15,9 @@ import chat.rocket.android.api.FileUploadingHelper;
 import chat.rocket.android.helper.LogcatIfError;
 import chat.rocket.android.helper.OkHttpHelper;
 import chat.rocket.android.log.RCLog;
-import chat.rocket.android.model.SyncState;
-import chat.rocket.android.model.internal.FileUploading;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.core.SyncState;
+import chat.rocket.persistence.realm.models.internal.FileUploading;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 import okhttp3.MediaType;
 import okhttp3.MultipartBody;

app/src/main/java/chat/rocket/android/service/observer/FileUploadingWithUfsObserver.java

@@ -13,11 +13,11 @@ import chat.rocket.android.api.FileUploadingHelper;
 import chat.rocket.android.helper.LogcatIfError;
 import chat.rocket.android.helper.OkHttpHelper;
 import chat.rocket.android.log.RCLog;
-import chat.rocket.android.model.SyncState;
-import chat.rocket.android.model.ddp.User;
-import chat.rocket.android.model.internal.FileUploading;
-import chat.rocket.android.model.internal.Session;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.core.SyncState;
+import chat.rocket.persistence.realm.models.ddp.RealmUser;
+import chat.rocket.persistence.realm.models.internal.FileUploading;
+import chat.rocket.persistence.realm.models.internal.RealmSession;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 import okhttp3.MediaType;
 import okhttp3.Request;
@@ -92,10 +92,10 @@ public class FileUploadingWithUfsObserver extends AbstractModelObserver<FileUplo
       return;
     }
 
-    User currentUser = realmHelper.executeTransactionForRead(realm ->
-        User.queryCurrentUser(realm).findFirst());
-    Session session = realmHelper.executeTransactionForRead(realm ->
-        Session.queryDefaultSession(realm).findFirst());
+    RealmUser currentUser = realmHelper.executeTransactionForRead(realm ->
+        RealmUser.queryCurrentUser(realm).findFirst());
+    RealmSession session = realmHelper.executeTransactionForRead(realm ->
+        RealmSession.queryDefaultSession(realm).findFirst());
     if (currentUser == null || session == null) {
       return;
     }

app/src/main/java/chat/rocket/android/service/observer/GcmPushRegistrationObserver.java

@@ -13,12 +13,12 @@ import bolts.Task;
 import chat.rocket.android.RocketChatCache;
 import chat.rocket.android.api.RaixPushHelper;
 import chat.rocket.android.helper.LogcatIfError;
-import chat.rocket.android.model.SyncState;
-import chat.rocket.android.model.ddp.PublicSetting;
-import chat.rocket.android.model.ddp.PublicSettingsConstants;
-import chat.rocket.android.model.ddp.User;
-import chat.rocket.android.model.internal.GcmPushRegistration;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.core.SyncState;
+import chat.rocket.persistence.realm.models.ddp.RealmPublicSetting;
+import chat.rocket.core.PublicSettingsConstants;
+import chat.rocket.persistence.realm.models.ddp.RealmUser;
+import chat.rocket.persistence.realm.models.internal.GcmPushRegistration;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
 /**
@@ -66,12 +66,12 @@ public class GcmPushRegistrationObserver extends AbstractModelObserver<GcmPushRe
   }
 
   private Task<Void> registerGcmTokenForServer() throws IOException {
-    final String senderId = PublicSetting
+    final String senderId = RealmPublicSetting
         .getString(realmHelper, PublicSettingsConstants.Push.GCM_PROJECT_NUMBER, "").trim();
 
     final String gcmToken = getGcmToken(senderId);
-    final User currentUser = realmHelper.executeTransactionForRead(realm ->
-        User.queryCurrentUser(realm).findFirst());
+    final RealmUser currentUser = realmHelper.executeTransactionForRead(realm ->
+        RealmUser.queryCurrentUser(realm).findFirst());
     final String userId = currentUser != null ? currentUser.getId() : null;
     final String pushId = RocketChatCache.getOrCreatePushId(context);
 

app/src/main/java/chat/rocket/android/service/observer/GetUsersOfRoomsProcedureObserver.java

@@ -9,9 +9,9 @@ import java.util.List;
 import bolts.Task;
 import chat.rocket.android.api.MethodCallHelper;
 import chat.rocket.android.log.RCLog;
-import chat.rocket.android.model.SyncState;
-import chat.rocket.android.model.internal.GetUsersOfRoomsProcedure;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.core.SyncState;
+import chat.rocket.persistence.realm.models.internal.GetUsersOfRoomsProcedure;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
 /**

app/src/main/java/chat/rocket/android/service/observer/LoadMessageProcedureObserver.java

@@ -10,10 +10,10 @@ import java.util.List;
 import bolts.Task;
 import chat.rocket.android.api.MethodCallHelper;
 import chat.rocket.android.log.RCLog;
-import chat.rocket.android.model.SyncState;
-import chat.rocket.android.model.ddp.Message;
-import chat.rocket.android.model.internal.LoadMessageProcedure;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.core.SyncState;
+import chat.rocket.persistence.realm.models.ddp.RealmMessage;
+import chat.rocket.persistence.realm.models.internal.LoadMessageProcedure;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
 /**
@@ -56,11 +56,11 @@ public class LoadMessageProcedureObserver extends AbstractModelObserver<LoadMess
     ).onSuccessTask(task ->
         methodCall.loadHistory(roomId, isReset ? 0 : timestamp, count, lastSeen)
             .onSuccessTask(_task -> {
-              Message lastMessage = realmHelper.executeTransactionForRead(realm ->
-                  realm.where(Message.class)
-                      .equalTo(Message.ROOM_ID, roomId)
-                      .equalTo(Message.SYNC_STATE, SyncState.SYNCED)
-                      .findAllSorted(Message.TIMESTAMP, Sort.ASCENDING).first(null));
+              RealmMessage lastMessage = realmHelper.executeTransactionForRead(realm ->
+                  realm.where(RealmMessage.class)
+                      .equalTo(RealmMessage.ROOM_ID, roomId)
+                      .equalTo(RealmMessage.SYNC_STATE, SyncState.SYNCED)
+                      .findAllSorted(RealmMessage.TIMESTAMP, Sort.ASCENDING).first(null));
               long lastTs = lastMessage != null ? lastMessage.getTimestamp() : 0;
               int messageCount = _task.getResult().length();
               return realmHelper.executeTransaction(realm ->

app/src/main/java/chat/rocket/android/service/observer/MethodCallObserver.java

@@ -8,9 +8,9 @@ import org.json.JSONObject;
 import java.util.List;
 import chat.rocket.android.helper.CheckSum;
 import chat.rocket.android.helper.LogcatIfError;
-import chat.rocket.android.model.SyncState;
-import chat.rocket.android.model.internal.MethodCall;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.core.SyncState;
+import chat.rocket.persistence.realm.models.internal.MethodCall;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 import chat.rocket.android_ddp.DDPClientCallback;
 

app/src/main/java/chat/rocket/android/service/observer/NewMessageObserver.java

@@ -9,15 +9,15 @@ import java.util.List;
 import chat.rocket.android.api.MethodCallHelper;
 import chat.rocket.android.helper.LogcatIfError;
 import chat.rocket.android.log.RCLog;
-import chat.rocket.android.model.SyncState;
-import chat.rocket.android.model.ddp.Message;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.core.SyncState;
+import chat.rocket.persistence.realm.models.ddp.RealmMessage;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
 /**
  * Observe messages for sending.
  */
-public class NewMessageObserver extends AbstractModelObserver<Message> {
+public class NewMessageObserver extends AbstractModelObserver<RealmMessage> {
 
   private final MethodCallHelper methodCall;
 
@@ -28,10 +28,10 @@ public class NewMessageObserver extends AbstractModelObserver<Message> {
 
     realmHelper.executeTransaction(realm -> {
       // resume pending operations.
-      RealmResults<Message> pendingMethodCalls = realm.where(Message.class)
-          .equalTo(Message.SYNC_STATE, SyncState.SYNCING)
+      RealmResults<RealmMessage> pendingMethodCalls = realm.where(RealmMessage.class)
+          .equalTo(RealmMessage.SYNC_STATE, SyncState.SYNCING)
           .findAll();
-      for (Message message : pendingMethodCalls) {
+      for (RealmMessage message : pendingMethodCalls) {
         message.setSyncState(SyncState.NOT_SYNCED);
       }
 
@@ -40,37 +40,37 @@ public class NewMessageObserver extends AbstractModelObserver<Message> {
   }
 
   @Override
-  public RealmResults<Message> queryItems(Realm realm) {
-    return realm.where(Message.class)
-        .equalTo(Message.SYNC_STATE, SyncState.NOT_SYNCED)
-        .isNotNull(Message.ROOM_ID)
+  public RealmResults<RealmMessage> queryItems(Realm realm) {
+    return realm.where(RealmMessage.class)
+        .equalTo(RealmMessage.SYNC_STATE, SyncState.NOT_SYNCED)
+        .isNotNull(RealmMessage.ROOM_ID)
         .findAll();
   }
 
   @Override
-  public void onUpdateResults(List<Message> results) {
+  public void onUpdateResults(List<RealmMessage> results) {
     if (results.isEmpty()) {
       return;
     }
 
-    final Message message = results.get(0);
+    final RealmMessage message = results.get(0);
     final String messageId = message.getId();
     final String roomId = message.getRoomId();
     final String msg = message.getMessage();
 
     realmHelper.executeTransaction(realm ->
-        realm.createOrUpdateObjectFromJson(Message.class, new JSONObject()
-            .put(Message.ID, messageId)
-            .put(Message.SYNC_STATE, SyncState.SYNCING)
+        realm.createOrUpdateObjectFromJson(RealmMessage.class, new JSONObject()
+            .put(RealmMessage.ID, messageId)
+            .put(RealmMessage.SYNC_STATE, SyncState.SYNCING)
         )
     ).onSuccessTask(task -> methodCall.sendMessage(messageId, roomId, msg)
     ).continueWith(task -> {
       if (task.isFaulted()) {
         RCLog.w(task.getError());
         realmHelper.executeTransaction(realm ->
-            realm.createOrUpdateObjectFromJson(Message.class, new JSONObject()
-                .put(Message.ID, messageId)
-                .put(Message.SYNC_STATE, SyncState.FAILED)));
+            realm.createOrUpdateObjectFromJson(RealmMessage.class, new JSONObject()
+                .put(RealmMessage.ID, messageId)
+                .put(RealmMessage.SYNC_STATE, SyncState.FAILED)));
       }
       return null;
     });

app/src/main/java/chat/rocket/android/service/observer/PushSettingsObserver.java

@@ -6,12 +6,12 @@ import io.realm.RealmResults;
 
 import java.util.List;
 import chat.rocket.android.helper.GcmPushSettingHelper;
-import chat.rocket.android.model.ddp.PublicSetting;
-import chat.rocket.android.model.internal.GcmPushRegistration;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.models.ddp.RealmPublicSetting;
+import chat.rocket.persistence.realm.models.internal.GcmPushRegistration;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
-public class PushSettingsObserver extends AbstractModelObserver<PublicSetting> {
+public class PushSettingsObserver extends AbstractModelObserver<RealmPublicSetting> {
 
   public PushSettingsObserver(Context context, String hostname,
                               RealmHelper realmHelper, DDPClientRef ddpClientRef) {
@@ -19,12 +19,12 @@ public class PushSettingsObserver extends AbstractModelObserver<PublicSetting> {
   }
 
   @Override
-  public RealmResults<PublicSetting> queryItems(Realm realm) {
+  public RealmResults<RealmPublicSetting> queryItems(Realm realm) {
     return GcmPushSettingHelper.queryForGcmPushEnabled(realm);
   }
 
   @Override
-  public void onUpdateResults(List<PublicSetting> results) {
+  public void onUpdateResults(List<RealmPublicSetting> results) {
     boolean gcmPushEnabled = GcmPushSettingHelper.isGcmPushEnabled(results);
 
     if (gcmPushEnabled) {

app/src/main/java/chat/rocket/android/service/observer/SessionObserver.java

@@ -8,11 +8,11 @@ import java.util.List;
 import chat.rocket.android.RocketChatCache;
 import chat.rocket.android.api.RaixPushHelper;
 import chat.rocket.android.helper.LogcatIfError;
-import chat.rocket.android.model.internal.GetUsersOfRoomsProcedure;
-import chat.rocket.android.model.internal.LoadMessageProcedure;
-import chat.rocket.android.model.internal.MethodCall;
-import chat.rocket.android.model.internal.Session;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.models.internal.GetUsersOfRoomsProcedure;
+import chat.rocket.persistence.realm.models.internal.LoadMessageProcedure;
+import chat.rocket.persistence.realm.models.internal.MethodCall;
+import chat.rocket.persistence.realm.models.internal.RealmSession;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 import chat.rocket.android.service.internal.StreamRoomMessageManager;
 import hugo.weaving.DebugLog;
@@ -20,7 +20,7 @@ import hugo.weaving.DebugLog;
 /**
  * Observes user is logged into server.
  */
-public class SessionObserver extends AbstractModelObserver<Session> {
+public class SessionObserver extends AbstractModelObserver<RealmSession> {
   private final StreamRoomMessageManager streamNotifyMessage;
   private final RaixPushHelper pushHelper;
   private int count;
@@ -38,16 +38,16 @@ public class SessionObserver extends AbstractModelObserver<Session> {
   }
 
   @Override
-  public RealmResults<Session> queryItems(Realm realm) {
-    return realm.where(Session.class)
-        .isNotNull(Session.TOKEN)
-        .equalTo(Session.TOKEN_VERIFIED, true)
-        .isNull(Session.ERROR)
+  public RealmResults<RealmSession> queryItems(Realm realm) {
+    return realm.where(RealmSession.class)
+        .isNotNull(RealmSession.TOKEN)
+        .equalTo(RealmSession.TOKEN_VERIFIED, true)
+        .isNull(RealmSession.ERROR)
         .findAll();
   }
 
   @Override
-  public void onUpdateResults(List<Session> results) {
+  public void onUpdateResults(List<RealmSession> results) {
     int origCount = count;
     count = results.size();
     if (origCount > 0 && count > 0) {

app/src/main/java/chat/rocket/android/service/observer/TokenLoginObserver.java

@@ -7,11 +7,11 @@ import io.realm.RealmResults;
 import java.util.List;
 import chat.rocket.android.api.MethodCallHelper;
 import chat.rocket.android.helper.LogcatIfError;
-import chat.rocket.android.model.internal.Session;
-import chat.rocket.android.realm_helper.RealmHelper;
+import chat.rocket.persistence.realm.models.internal.RealmSession;
+import chat.rocket.persistence.realm.RealmHelper;
 import chat.rocket.android.service.DDPClientRef;
 
-public class TokenLoginObserver extends AbstractModelObserver<Session> {
+public class TokenLoginObserver extends AbstractModelObserver<RealmSession> {
 
   private final MethodCallHelper methodCall;
 
@@ -22,21 +22,21 @@ public class TokenLoginObserver extends AbstractModelObserver<Session> {
   }
 
   @Override
-  public RealmResults<Session> queryItems(Realm realm) {
-    return realm.where(Session.class)
-        .isNotNull(Session.TOKEN)
-        .equalTo(Session.TOKEN_VERIFIED, false)
-        .isNull(Session.ERROR)
+  public RealmResults<RealmSession> queryItems(Realm realm) {
+    return realm.where(RealmSession.class)
+        .isNotNull(RealmSession.TOKEN)
+        .equalTo(RealmSession.TOKEN_VERIFIED, false)
+        .isNull(RealmSession.ERROR)
         .findAll();
   }
 
   @Override
-  public void onUpdateResults(List<Session> results) {
+  public void onUpdateResults(List<RealmSession> results) {
     if (results.isEmpty()) {
       return;
     }
 
-    Session session = results.get(0);
+    RealmSession session = results.get(0);
     methodCall.loginWithToken(session.getToken()).continueWith(new LogcatIfError());
   }
 }

app/src/main/java/chat/rocket/android/shared/BaseContract.java

+package chat.rocket.android.shared;
+
+import android.support.annotation.NonNull;
+
+public interface BaseContract {
+
+  interface View {
+  }
+
+  interface Presenter<T extends View> {
+    void bindView(@NonNull T view);
+
+    void release();
+  }
+}

app/src/main/java/chat/rocket/android/shared/BasePresenter.java

+package chat.rocket.android.shared;
+
+import android.support.annotation.NonNull;
+
+import rx.Subscription;
+import rx.subscriptions.CompositeSubscription;
+
+public abstract class BasePresenter<T extends BaseContract.View>
+    implements BaseContract.Presenter<T> {
+
+  protected T view;
+  private CompositeSubscription compositeSubscription = new CompositeSubscription();
+
+  @Override
+  public void bindView(@NonNull T view) {
+    this.view = view;
+  }
+
+  @Override
+  public void release() {
+    compositeSubscription.clear();
+    view = null;
+  }
+
+  protected void addSubscription(Subscription subscription) {
+    compositeSubscription.add(subscription);
+  }
+
+  protected void clearSubscripions() {
+    compositeSubscription.clear();
+  }
+}

app/src/main/res/layout/fragment_sidebar_main.xml

@@ -3,7 +3,9 @@
         xmlns:tools="http://schemas.android.com/tools"
         android:layout_width="match_parent"
         android:layout_height="match_parent"
-        android:theme="@style/AppTheme.Dark">
+        android:theme="@style/AppTheme.Dark"
+        android:visibility="invisible"
+        tools:visibility="visible">
 
     <LinearLayout
             android:id="@+id/user_info_container"

config/quality/pmd/pmd-ruleset.xml

@@ -9,20 +9,20 @@
     <exclude-pattern>.*/R.java</exclude-pattern>
     <exclude-pattern>.*/gen/.*</exclude-pattern>
 
-    <rule ref="rulesets/java/android.xml"/>
-    <rule ref="rulesets/java/clone.xml"/>
-    <rule ref="rulesets/java/finalizers.xml"/>
+    <rule ref="rulesets/java/android.xml" />
+    <rule ref="rulesets/java/clone.xml" />
+    <rule ref="rulesets/java/finalizers.xml" />
     <rule ref="rulesets/java/imports.xml">
         <!-- Espresso is designed this way !-->
-        <exclude name="TooManyStaticImports"/>
+        <exclude name="TooManyStaticImports" />
     </rule>
-    <rule ref="rulesets/java/basic.xml"/>
+    <rule ref="rulesets/java/basic.xml" />
     <rule ref="rulesets/java/naming.xml">
-        <!--<exclude name="AbstractNaming" />-->
-        <exclude name="LongVariable"/>
+        <exclude name="AbstractNaming" />
+        <exclude name="LongVariable" />
         <!--exclude name="ShortMethodName" /-->
         <!--exclude name="ShortVariable" /-->
-        <!--<exclude name="ShortClassName" />-->
+        <exclude name="ShortClassName" />
         <!--<exclude name="VariableNamingConventions" />-->
     </rule>
 </ruleset>
\ No newline at end of file

gradle.properties

@@ -6,8 +6,12 @@
 # http://www.gradle.org/docs/current/userguide/build_environment.html
 # Specifies the JVM arguments used for the daemon process.
 # The setting is particularly useful for tweaking memory settings.
-org.gradle.jvmargs=-Xmx1536m
+# org.gradle.jvmargs=-Xmx1536m
 # When configured, Gradle will run in incubating parallel mode.
 # This option should only be used with decoupled projects. More details, visit
 # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
 # org.gradle.parallel=true
+
+org.gradle.jvmargs=-Xmx6144M
+#org.gradle.parallel=true
+android.enableBuildCache=true
\ No newline at end of file

realm-helpers/build.gradle → persistence-realm/build.gradle

 apply plugin: 'com.android.library'
 apply plugin: 'realm-android'
+apply plugin: 'com.jakewharton.hugo'
 apply plugin: 'me.tatarka.retrolambda'
 
 buildscript {
@@ -11,6 +12,7 @@ buildscript {
     classpath rootProject.ext.realmPlugin
     classpath rootProject.ext.retroLambdaPlugin
     classpath rootProject.ext.retroLambdaPatch
+    classpath 'com.jakewharton.hugo:hugo-plugin:1.2.1'
   }
 }
 
@@ -39,6 +41,9 @@ android {
 dependencies {
   testCompile 'junit:junit:4.12'
   compile project(':log-wrapper')
+  compile project(':rocket-chat-core')
+  compile 'io.reactivex:rxjava:1.2.3'
+  compile 'io.reactivex:rxandroid:1.2.1'
   compile rootProject.ext.boltsTask
   compile rootProject.ext.supportAnnotations
   compile rootProject.ext.supportAppCompat

persistence-realm/src/main/AndroidManifest.xml

+<manifest package="chat.rocket.persistence.realm"/>
\ No newline at end of file

realm-helpers/src/main/java/chat/rocket/android/realm_helper/AbstractRealmResultsObserver.java → persistence-realm/src/main/java/chat/rocket/persistence/realm/AbstractRealmResultsObserver.java

-package chat.rocket.android.realm_helper;
+package chat.rocket.persistence.realm;
 
 import io.realm.Realm;
 import io.realm.RealmChangeListener;

realm-helpers/src/main/java/chat/rocket/android/realm_helper/RealmAutoCompleteAdapter.java → persistence-realm/src/main/java/chat/rocket/persistence/realm/RealmAutoCompleteAdapter.java

-package chat.rocket.android.realm_helper;
+package chat.rocket.persistence.realm;
 
 import android.content.Context;
 import android.support.annotation.NonNull;

realm-helpers/src/main/java/chat/rocket/android/realm_helper/RealmHelper.java → persistence-realm/src/main/java/chat/rocket/persistence/realm/RealmHelper.java

-package chat.rocket.android.realm_helper;
+package chat.rocket.persistence.realm;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.os.Looper;
-import android.support.v7.widget.RecyclerView;
 import io.realm.Realm;
 import io.realm.RealmConfiguration;
 import io.realm.RealmObject;
@@ -158,12 +157,6 @@ public class RealmHelper {
     return new RealmObjectObserver<T>(this, query);
   }
 
-  public <T extends RealmObject, VM, VH extends RealmModelViewHolder<VM>>
-  RecyclerView.Adapter<VH> createListAdapter(Context context, RealmListObserver.Query<T> query,
-                                             RealmModelListAdapter.Constructor<T, VM, VH> constructor) {
-    return constructor.getNewInstance(context).initializeWith(this, query);
-  }
-
   public <T extends RealmObject> RealmAutoCompleteAdapter<T> createAutoCompleteAdapter(
       Context context,
       RealmAutoCompleteAdapter.RealmFilter<T> filter,

realm-helpers/src/main/java/chat/rocket/android/realm_helper/RealmListObserver.java → persistence-realm/src/main/java/chat/rocket/persistence/realm/RealmListObserver.java

-package chat.rocket.android.realm_helper;
+package chat.rocket.persistence.realm;
 
 import io.realm.Realm;
 import io.realm.RealmChangeListener;

realm-helpers/src/main/java/chat/rocket/android/realm_helper/RealmObjectObserver.java → persistence-realm/src/main/java/chat/rocket/persistence/realm/RealmObjectObserver.java

-package chat.rocket.android.realm_helper;
+package chat.rocket.persistence.realm;
 
 import io.realm.Realm;
 import io.realm.RealmChangeListener;

realm-helpers/src/main/java/chat/rocket/android/realm_helper/RealmStore.java → persistence-realm/src/main/java/chat/rocket/persistence/realm/RealmStore.java

-package chat.rocket.android.realm_helper;
+package chat.rocket.persistence.realm;
 
+import io.realm.Realm;
 import io.realm.RealmConfiguration;
 
 import java.util.HashMap;
+import chat.rocket.persistence.realm.modules.RocketChatLibraryModule;
+import chat.rocket.persistence.realm.modules.RocketChatServerModule;
 
 public class RealmStore {
   public static HashMap<String, RealmConfiguration> sStore = new HashMap<>();
@@ -10,6 +13,7 @@ public class RealmStore {
   private static RealmConfiguration createConfigFor(String name) {
     return new RealmConfiguration.Builder()
         .name(name + ".realm")
+        .modules(new RocketChatLibraryModule())
         .deleteRealmIfMigrationNeeded().build();
   }
 
@@ -35,4 +39,24 @@ public class RealmStore {
     }
     return new RealmHelper(sStore.get(name));
   }
+
+  public static RealmHelper getOrCreateForServerScope(String name) {
+    if (!sStore.containsKey(name)) {
+      sStore.put(name, new RealmConfiguration.Builder()
+          .name(name + ".realm")
+          .modules(new RocketChatServerModule())
+          .deleteRealmIfMigrationNeeded().build());
+    }
+    return new RealmHelper(sStore.get(name));
+  }
+
+  public static Realm getRealm(String name) {
+    RealmHelper realmHelper = get(name);
+
+    if (realmHelper == null) {
+      return null;
+    }
+
+    return realmHelper.instance();
+  }
 }

persistence-realm/src/main/java/chat/rocket/persistence/realm/RocketChatPersistenceRealm.java

+package chat.rocket.persistence.realm;
+
+import android.content.Context;
+import io.realm.Realm;
+import io.realm.RealmConfiguration;
+
+import chat.rocket.persistence.realm.modules.RocketChatLibraryModule;
+
+public class RocketChatPersistenceRealm {
+
+  public static void init(Context context) {
+    Realm.init(context);
+
+    Realm.setDefaultConfiguration(
+        new RealmConfiguration.Builder()
+            .name("rocket.chat.persistence.realm")
+            .modules(new RocketChatLibraryModule())
+            .deleteRealmIfMigrationNeeded()
+            .build());
+  }
+}

persistence-realm/src/main/java/chat/rocket/persistence/realm/helpers/LogcatIfError.java

+package chat.rocket.persistence.realm.helpers;
+
+import bolts.Continuation;
+import bolts.Task;
+import chat.rocket.android.log.RCLog;
+
+/**
+ * Bolts-Task continuation for just logging if error occurred.
+ */
+public class LogcatIfError implements Continuation {
+  @Override
+  public Object then(Task task) throws Exception {
+    if (task.isFaulted()) {
+      RCLog.w(task.getError());
+    }
+    return task;
+  }
+}

app/src/main/java/chat/rocket/android/service/RealmBasedServerInfo.java → persistence-realm/src/main/java/chat/rocket/persistence/realm/models/RealmBasedServerInfo.java

-package chat.rocket.android.service;
+package chat.rocket.persistence.realm.models;
 
 import android.support.annotation.Nullable;
 import android.text.TextUtils;
@@ -9,14 +9,15 @@ import org.json.JSONObject;
 
 import java.util.ArrayList;
 import java.util.List;
-import chat.rocket.android.realm_helper.RealmHelper;
-import chat.rocket.android.realm_helper.RealmStore;
+import chat.rocket.core.models.ServerInfo;
+import chat.rocket.persistence.realm.RealmHelper;
+import chat.rocket.persistence.realm.RealmStore;
 
 /**
  * Backend implementation to store ServerInfo.
  */
 public class RealmBasedServerInfo extends RealmObject {
-  private static final String DB_NAME = "serverlist";
+  private static final String DB_NAME = "server.list";
 
   @PrimaryKey private String hostname;
   private String name;
@@ -31,21 +32,26 @@ public class RealmBasedServerInfo extends RealmObject {
   }
 
   ServerInfo getServerInfo() {
-    return new ServerInfo(hostname, name, session, insecure);
+    return ServerInfo.builder()
+        .setHostname(hostname)
+        .setName(name)
+        .setSession(session)
+        .setSecure(!insecure)
+        .build();
   }
 
-  static RealmHelper getRealm() {
-    return RealmStore.getOrCreate(DB_NAME);
+  public static RealmHelper getRealm() {
+    return RealmStore.getOrCreateForServerScope(DB_NAME);
   }
 
-  static void addOrUpdate(String hostname, String name) {
+  public static void addOrUpdate(String hostname, String name) {
     getRealm().executeTransaction(realm ->
         realm.createOrUpdateObjectFromJson(RealmBasedServerInfo.class, new JSONObject()
             .put(ColumnName.HOSTNAME, hostname)
             .put(ColumnName.NAME, TextUtils.isEmpty(name) ? JSONObject.NULL : name)));
   }
 
-  static void remove(String hostname) {
+  public static void remove(String hostname) {
     getRealm().executeTransaction(realm -> {
       realm.where(RealmBasedServerInfo.class).equalTo(ColumnName.HOSTNAME, hostname)
           .findAll()
@@ -54,7 +60,7 @@ public class RealmBasedServerInfo extends RealmObject {
     });
   }
 
-  static void updateSession(String hostname, String session) {
+  public static void updateSession(String hostname, String session) {
     RealmBasedServerInfo impl = getRealm().executeTransactionForRead(realm ->
         realm.where(RealmBasedServerInfo.class).equalTo(ColumnName.HOSTNAME, hostname).findFirst());
 
@@ -67,13 +73,14 @@ public class RealmBasedServerInfo extends RealmObject {
     }
   }
 
-  static @Nullable ServerInfo getServerInfoForHost(String hostname) {
+  @Nullable
+  public static ServerInfo getServerInfoForHost(String hostname) {
     RealmBasedServerInfo impl = getRealm().executeTransactionForRead(realm ->
         realm.where(RealmBasedServerInfo.class).equalTo(ColumnName.HOSTNAME, hostname).findFirst());
     return impl == null ? null : impl.getServerInfo();
   }
 
-  static void setInsecure(String hostname, boolean insecure) {
+  public static void setInsecure(String hostname, boolean insecure) {
     RealmBasedServerInfo impl = getRealm().executeTransactionForRead(realm ->
         realm.where(RealmBasedServerInfo.class).equalTo(ColumnName.HOSTNAME, hostname).findFirst());
 
@@ -86,7 +93,7 @@ public class RealmBasedServerInfo extends RealmObject {
     }
   }
 
-  static List<ServerInfo> getServerInfoList() {
+  public static List<ServerInfo> getServerInfoList() {
     List<RealmBasedServerInfo> results = getRealm().executeTransactionForReadResults(realm ->
         realm.where(RealmBasedServerInfo.class).findAll());
     ArrayList<ServerInfo> list = new ArrayList<>();