Merge pull request #104 from qiscus/feature/background_thread

Feature/background thread

README.md

@@ -54,7 +54,7 @@ Second, you need to add SDK dependencies inside your app .gradle. Then, you need
 ```
 dependencies { 
        ... 
-       implementation 'com.qiscus.sdk:chat-core:1.6.10'
+       implementation 'com.qiscus.sdk:chat-core:1.7.1'
 }
 ```
 

app/src/main/AndroidManifest.xml

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.qiscus.dragonfly">
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
 
     <application
         android:name=".SampleApps"

app/src/main/java/com/qiscus/dragonfly/SampleApps.java

@@ -25,6 +25,12 @@
 import com.qiscus.sdk.chat.core.QiscusCore;
 import com.qiscus.sdk.data.model.QiscusDeleteCommentConfig;
 
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
 /**
  * Created on : August 18, 2016
  * Author     : zetbaitsu
@@ -36,14 +42,18 @@ public class SampleApps extends MultiDexApplication {
     @Override
     public void onCreate() {
         super.onCreate();
+            try {
+                QiscusCore.setCustomHeader(new JSONObject("{\"QISCUS-OMNICHANNEL\": \"mobile-agent-android\"}"));
+            } catch (JSONException e) {
+                // ignored
+            }
+        Executors.newSingleThreadExecutor().execute(() -> {
+
+            Qiscus.setup(this, QISCUS_SDK_APP_ID);
 
-        Qiscus.setup(this, QISCUS_SDK_APP_ID);
 
-        // for test refresh token
-//        Qiscus.setupWithCustomServer(
-//                this, "dragongo", "https://dragongo.qiscus.com",
-//                "ssl://realtime-stag.qiscus.com", null
-//        );
+
+        });
 
         Qiscus.getChatConfig()
                 .enableDebugMode(true)
@@ -52,6 +62,13 @@ public void onCreate() {
                         .setEnableDeleteComment(true)
                         .setEnableHardDelete(true));
 
+        // for test refresh token
+//        Qiscus.setupWithCustomServer(
+//                this, "dragongo", "https://dragongo.qiscus.com",
+//                "ssl://realtime-stag.qiscus.com", null
+//        );
+
+
         Stetho.initializeWithDefaults(this);
     }
 }

chat-core/src/main/java/com/qiscus/sdk/chat/core/QiscusAppComponent.java

@@ -0,0 +1,242 @@
+package com.qiscus.sdk.chat.core;
+
+import android.app.Application;
+import android.os.Handler;
+
+import com.qiscus.sdk.chat.core.data.local.QiscusDataBaseHelper;
+import com.qiscus.sdk.chat.core.data.local.QiscusDataStore;
+import com.qiscus.sdk.chat.core.util.QiscusTextUtil;
+
+import org.json.JSONObject;
+
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+
+public class QiscusAppComponent {
+
+    private Application application;
+    private String appId;
+    private String baseURLLB;
+    private String mqttBrokerUrl;
+    private String appServer;
+    private boolean enableMqttLB = true;
+    private int heartBeat = 5000;
+    private int automaticHeartBeat = 30000;
+    private int networkConnectionInterval = 5000;
+    private Boolean enableRealtime = true;
+    private Boolean enableEventReport = true;
+    private Boolean isBuiltIn = false;
+    private Boolean syncServiceDisabled = false;
+    private Boolean enableSync = true;
+    private Boolean enableSyncEvent = false;
+    private Boolean autoRefreshToken = true;
+    private Boolean enableRefreshToken = false;
+    private Boolean forceDisableRealtimeFromExactAlarm = false;
+    private JSONObject customHeader;
+    private Handler appHandler;
+    private final ScheduledThreadPoolExecutor taskExecutor = new ScheduledThreadPoolExecutor(5);
+    private QiscusCore.LocalDataManager localDataManager;
+
+    private QiscusDataBaseHelper dataBaseHelper;
+    private QiscusDataStore dataStore;
+    private static volatile QiscusAppComponent INSTANCE;
+
+
+    public static QiscusAppComponent create() {
+        synchronized (QiscusAppComponent.class) {
+            INSTANCE = new QiscusAppComponent();
+        }
+        return INSTANCE;
+    }
+
+    public static QiscusAppComponent getInstance() {
+        if (INSTANCE == null) {
+            synchronized (QiscusAppComponent.class) {
+                if (INSTANCE == null) {
+                    throw new IllegalArgumentException("Failed QiscusAppComponent getInstance()");
+                }
+            }
+        }
+        return INSTANCE;
+    }
+
+    public synchronized void setup(Application application, String qiscusAppId, String serverBaseUrl) {
+        this.application = application;
+        this.appId = qiscusAppId;
+        this.appServer = !serverBaseUrl.endsWith("/") ? serverBaseUrl + "/" : serverBaseUrl;
+        this.appHandler =  new Handler(application.getMainLooper());
+        this.localDataManager = new QiscusCore.LocalDataManager(application);
+        //this.chatConfig = new QiscusCoreChatConfig();
+        this.dataStore = new QiscusDataBaseHelper(application);
+        QiscusTextUtil.createInstance(application);
+    }
+
+    public synchronized Application getApplication() {
+        return application;
+    }
+
+    public synchronized String getAppId() {
+        return appId;
+    }
+
+    public synchronized String getAppServer() {
+        return appServer;
+    }
+
+    public synchronized void setAppServer(String appServer) {
+        this.appServer = appServer;
+    }
+
+    public synchronized int getHeartBeat() {
+        return heartBeat;
+    }
+
+    public synchronized void setHeartBeat(int heartBeat) {
+        this.heartBeat = heartBeat;
+    }
+
+    public synchronized int getAutomaticHeartBeat() {
+        return automaticHeartBeat;
+    }
+
+    public synchronized void setAutomaticHeartBeat(int automaticHeartBeat) {
+        this.automaticHeartBeat = automaticHeartBeat;
+    }
+
+    public synchronized int getNetworkConnectionInterval() {
+        return networkConnectionInterval;
+    }
+
+    public synchronized void setNetworkConnectionInterval(int automaticHeartBeatnetworkConnectionInterval) {
+        this.networkConnectionInterval = networkConnectionInterval;
+    }
+
+    public synchronized Boolean getEnableEventReport() {
+        return enableEventReport;
+    }
+
+    public synchronized void setEnableEventReport(Boolean enableEventReport) {
+        this.enableEventReport = enableEventReport;
+    }
+
+    public synchronized String getBaseURLLB() {
+        return baseURLLB;
+    }
+
+    public synchronized void setBaseURLLB(String baseURLLB) {
+        this.baseURLLB = baseURLLB;
+    }
+
+    public synchronized Boolean getIsBuiltIn() {
+        return isBuiltIn;
+    }
+
+    public synchronized void setIsBuiltIn(Boolean isBuiltIn) {
+        this.isBuiltIn = isBuiltIn;
+    }
+
+    public synchronized String getMqttBrokerUrl() {
+        return mqttBrokerUrl;
+    }
+
+    public synchronized void setMqttBrokerUrl(String mqttBrokerUrl) {
+        this.mqttBrokerUrl = mqttBrokerUrl;
+    }
+
+    public synchronized Boolean getEnableMqttLB() {
+        return enableMqttLB;
+    }
+
+    public synchronized void setEnableMqttLB(Boolean enableMqttLB) {
+        this.enableMqttLB = enableMqttLB;
+    }
+
+    public synchronized Boolean getEnableRealtime() {
+        return enableRealtime;
+    }
+
+    public synchronized void setEnableRealtime(Boolean enableRealtime) {
+        this.enableRealtime = enableRealtime;
+    }
+
+    public synchronized Boolean getSyncServiceDisabled() {
+        return syncServiceDisabled;
+    }
+
+    public synchronized void setSyncServiceDisabled(Boolean syncServiceDisabled) {
+        this.syncServiceDisabled = syncServiceDisabled;
+    }
+
+    public synchronized Boolean getEnableSync() {
+        return enableSync;
+    }
+
+    public synchronized void setEnableSync(Boolean enableSync) {
+        this.enableSync = enableSync;
+    }
+
+    public synchronized Boolean getEnableSyncEvent() {
+        return enableSyncEvent;
+    }
+
+    public synchronized void setEnableSyncEvent(Boolean enableSyncEvent) {
+        this.enableSyncEvent = enableSyncEvent;
+    }
+
+    public synchronized Boolean getAutoRefreshToken() {
+        return autoRefreshToken;
+    }
+
+    public synchronized void setAutoRefreshToken(Boolean autoRefreshToken) {
+        this.autoRefreshToken = autoRefreshToken;
+    }
+
+    public synchronized Boolean getEnableRefreshToken() {
+        return enableRefreshToken;
+    }
+
+    public synchronized void setEnableRefreshToken(Boolean enableRefreshToken) {
+        this.enableRefreshToken = enableRefreshToken;
+    }
+
+
+    public synchronized Boolean getForceDisableRealtimeFromExactAlarm() {
+        return forceDisableRealtimeFromExactAlarm;
+    }
+
+    public synchronized void setForceDisableRealtimeFromExactAlarm(Boolean forceDisableRealtimeFromExactAlarm) {
+        this.forceDisableRealtimeFromExactAlarm = forceDisableRealtimeFromExactAlarm;
+    }
+
+    public synchronized JSONObject getCustomHeader() {
+        return customHeader;
+    }
+
+    public synchronized void setCustomHeader(JSONObject customHeader) {
+        this.customHeader = customHeader;
+    }
+
+    public synchronized Handler getAppHandler() {
+        return appHandler;
+    }
+
+    public synchronized ScheduledThreadPoolExecutor getTaskExecutor() {
+        return taskExecutor;
+    }
+
+    public synchronized QiscusCore.LocalDataManager getLocalDataManager() {
+        return localDataManager;
+    }
+
+    public synchronized QiscusDataBaseHelper getDataBaseHelper() {
+        return dataBaseHelper;
+    }
+
+    public synchronized QiscusDataStore getDataStore() {
+        return dataStore;
+    }
+
+    public synchronized  void setDataStore(QiscusDataStore qiscusDataStore) {
+        this.dataStore = qiscusDataStore;
+    }
+
+}