Implement CSI

app/src/main/java/org/mercury_im/messenger/MercuryImApplication.java

@@ -1,12 +1,15 @@
 package org.mercury_im.messenger;
 
+import android.app.Activity;
 import android.app.Application;
 import android.app.NotificationChannel;
 import android.app.NotificationManager;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Build;
+import android.os.Bundle;
 
+import org.jivesoftware.smackx.csi.ClientStateIndicationManager;
 import org.mercury_im.messenger.core.centers.ConnectionCenter;
 import org.mercury_im.messenger.core.connection.MercuryConfiguration;
 import org.mercury_im.messenger.di.component.AppComponent;
@@ -15,6 +18,10 @@ import org.mercury_im.messenger.di.module.AppModule;
 import org.mercury_im.messenger.persistence.room.RoomModule;
 import org.mercury_im.messenger.persistence.room.RoomRepositoryModule;
 import org.mercury_im.messenger.service.XmppConnectionService;
+import org.mercury_im.messenger.util.AbstractActivityLifecycleCallbacks;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import javax.inject.Inject;
 
@@ -30,17 +37,24 @@ public class MercuryImApplication extends Application {
     private static MercuryImApplication INSTANCE;
     AppComponent appComponent;
 
+    // Keep track of activities in "started" state.
+    // This will come in handy for CSI
+    private AtomicInteger activityReferences = new AtomicInteger(0);
+    private AtomicBoolean isActivityChangingConfiguration = new AtomicBoolean(false);
+
+    @Inject
+    ConnectionCenter connectionCenter;
+
     public static MercuryImApplication getApplication() {
         return INSTANCE;
     }
 
-    @Inject
-    ConnectionCenter connectionCenter;
 
     @Override
     public void onCreate() {
 
         super.onCreate();
+        registerActivityLifecycleCallbacks(lifecycleCallbacks);
 
         INSTANCE = this;
 
@@ -98,4 +112,24 @@ public class MercuryImApplication extends Application {
     public AppComponent getAppComponent() {
         return appComponent;
     }
+
+    private final AbstractActivityLifecycleCallbacks lifecycleCallbacks = new AbstractActivityLifecycleCallbacks() {
+
+        @Override
+        public void onActivityStarted(Activity activity) {
+            if (activityReferences.incrementAndGet() == 1 && !isActivityChangingConfiguration.get()) {
+                // App enters foreground
+                connectionCenter.clientStateActive();
+            }
+        }
+
+        @Override
+        public void onActivityStopped(Activity activity) {
+            isActivityChangingConfiguration.set(activity.isChangingConfigurations());
+            if (activityReferences.decrementAndGet() == 0 && !isActivityChangingConfiguration.get()) {
+                // App enters background
+                connectionCenter.clientStateInactive();
+            }
+        }
+    };
 }

app/src/main/java/org/mercury_im/messenger/util/AbstractActivityLifecycleCallbacks.java

@@ -0,0 +1,42 @@
+package org.mercury_im.messenger.util;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+
+public abstract class AbstractActivityLifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
+    @Override
+    public void onActivityCreated(Activity activity, Bundle bundle) {
+
+    }
+
+    @Override
+    public void onActivityStarted(Activity activity) {
+
+    }
+
+    @Override
+    public void onActivityResumed(Activity activity) {
+
+    }
+
+    @Override
+    public void onActivityPaused(Activity activity) {
+
+    }
+
+    @Override
+    public void onActivityStopped(Activity activity) {
+
+    }
+
+    @Override
+    public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
+
+    }
+
+    @Override
+    public void onActivityDestroyed(Activity activity) {
+
+    }
+}

core/src/main/java/org/mercury_im/messenger/core/centers/ConnectionCenter.java

@@ -1,9 +1,12 @@
 package org.mercury_im.messenger.core.centers;
 
 import org.jivesoftware.smack.AbstractXMPPConnection;
+import org.jivesoftware.smack.SmackException;
+import org.jivesoftware.smack.XMPPConnection;
 import org.jivesoftware.smack.tcp.XMPPTCPConnection;
 import org.jivesoftware.smack.tcp.XMPPTCPConnectionConfiguration;
 import org.jivesoftware.smackx.caps.EntityCapsManager;
+import org.jivesoftware.smackx.csi.ClientStateIndicationManager;
 import org.mercury_im.messenger.core.stores.EntityCapsStore;
 import org.mercury_im.messenger.core.connection.MercuryConfiguration;
 import org.mercury_im.messenger.core.connection.MercuryConnection;
@@ -150,4 +153,36 @@ public class ConnectionCenter {
         AbstractXMPPConnection tcpConnection = new XMPPTCPConnection(configuration);
         return new MercuryConnection(tcpConnection, accountModel.getId());
     }
+
+    public void clientStateActive() {
+        LOGGER.log(Level.INFO, "CSI: App is going to foreground -> active");
+        for (MercuryConnection mercuryConnection : connectionMap.values()) {
+            XMPPConnection connection = mercuryConnection.getConnection();
+            if (connection.isConnected() && ClientStateIndicationManager.isSupported(connection)) {
+                try {
+                    ClientStateIndicationManager.active(mercuryConnection.getConnection());
+                } catch (SmackException.NotConnectedException e) {
+                    e.printStackTrace();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+    public void clientStateInactive() {
+        LOGGER.log(Level.INFO, "CSI: App is going to background -> inactive");
+        for (MercuryConnection mercuryConnection : connectionMap.values()) {
+            XMPPConnection connection = mercuryConnection.getConnection();
+            if (connection.isConnected() && ClientStateIndicationManager.isSupported(connection)) {
+                try {
+                    ClientStateIndicationManager.inactive(connection);
+                } catch (SmackException.NotConnectedException e) {
+                    e.printStackTrace();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
 }