smartmessage-react-native 2.11.2

package/android/src/main/java/tr/com/odc/RNSmartMessage/RNSmartMessageModule.java

@@ -0,0 +1,774 @@
+package tr.com.odc.RNSmartMessage;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import tr.com.odc.smartmessage.SmartMessage;
+import tr.com.odc.smartmessage.push.model.AudioNotificationModel;
+import tr.com.odc.smartmessage.push.model.BaseNotificationModel;
+import tr.com.odc.smartmessage.push.model.BasicCarouselNotificationModel;
+import tr.com.odc.smartmessage.push.model.BasicNotificationModel;
+import tr.com.odc.smartmessage.push.model.CoverflowCarouselNotificationModel;
+import tr.com.odc.smartmessage.push.model.FullscreenDialogModel;
+import tr.com.odc.smartmessage.push.model.GifNotificationModel;
+import tr.com.odc.smartmessage.push.model.HTMLDialogModel;
+import tr.com.odc.smartmessage.push.model.HTMLNotificationModel;
+import tr.com.odc.smartmessage.push.model.ImageNotificationModel;
+import tr.com.odc.smartmessage.push.model.InteractiveDialogModel;
+import tr.com.odc.smartmessage.push.model.MediumDialogModel;
+import tr.com.odc.smartmessage.push.model.RotaryCarouselNotificationModel;
+import tr.com.odc.smartmessage.push.model.SliderNotificationModel;
+import tr.com.odc.smartmessage.push.model.SmallDialogModel;
+import tr.com.odc.smartmessage.push.model.VideoNotificationModel;
+import tr.com.odc.smartmessage.request.MatchContactDeviceRequestBody;
+import tr.com.odc.smartmessage.request.MessageListRequestBody;
+import tr.com.odc.smartmessage.request.model.UserInfo;
+import tr.com.odc.smartmessage.response.BaseResponse;
+import tr.com.odc.smartmessage.response.MessageListResponse;
+import tr.com.odc.smartmessage.response.UserInfoResponse;
+import tr.com.odc.smartmessage.sender.MessageListGetter;
+import tr.com.odc.smartmessage.sender.ResponseListener;
+import tr.com.odc.smartmessage.sender.StorageSender;
+import tr.com.odc.smartmessage.sender.UserInfoGetter;
+import tr.com.odc.smartmessage.storage.MessageDBListenerInterface;
+import tr.com.odc.smartmessage.storage.MessageEntity;
+import tr.com.odc.smartmessage.type.PermissionType;
+import tr.com.odc.smartmessage.type.PushType;
+import tr.com.odc.smartmessage.util.PermissionManager;
+import tr.com.odc.smartmessage.util.SMLogger;
+
+public class RNSmartMessageModule extends ReactContextBaseJavaModule {
+
+    private static final String TAG = "RNSmartMessageModule";
+
+    public RNSmartMessageModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    private final Map<PushType, Class<? extends BaseNotificationModel>> notificationTypes = new HashMap<PushType, Class<? extends BaseNotificationModel>>() {{
+        put(PushType.BASIC, BasicNotificationModel.class);
+        put(PushType.IMAGE, ImageNotificationModel.class);
+        put(PushType.HTML_PUSH, HTMLNotificationModel.class);
+        put(PushType.GIF, GifNotificationModel.class);
+        put(PushType.VIDEO, VideoNotificationModel.class);
+        put(PushType.AUDIO, AudioNotificationModel.class);
+        put(PushType.BASIC_CAROUSEL, BasicCarouselNotificationModel.class);
+        put(PushType.ROTARY_CAROUSEL, RotaryCarouselNotificationModel.class);
+        put(PushType.COVERFLOW_CAROUSEL, CoverflowCarouselNotificationModel.class);
+        put(PushType.SLIDER, SliderNotificationModel.class);
+        put(PushType.SMALL_DIALOG, SmallDialogModel.class);
+        put(PushType.MEDIUM_DIALOG, MediumDialogModel.class);
+        put(PushType.FULLSCREEN_DIALOG, FullscreenDialogModel.class);
+        put(PushType.INTERACTIVE_DIALOG, InteractiveDialogModel.class);
+        put(PushType.HTML_DIALOG, HTMLDialogModel.class);
+    }};
+
+    private BaseNotificationModel convertJSONToNotificationModel(String notificationString) throws Exception {
+
+        if (notificationString == null) {
+            throw (new Exception("notificationString is null.Request wont be completed"));
+        }
+
+        try {
+
+            BaseNotificationModel baseNotificationModel = new Gson().fromJson(notificationString, BaseNotificationModel.class);
+
+            if (baseNotificationModel == null || baseNotificationModel.getType() == null) {
+                throw (new Exception("notificationString string could not be converted into a BaseNotificationModel object."));
+            }
+
+            Class<? extends BaseNotificationModel> targetClass = notificationTypes.get(baseNotificationModel.getType());
+
+            if (targetClass == null) {
+                throw (new Exception("Unknown notification type : " + baseNotificationModel.getType()));
+            }
+
+            final BaseNotificationModel notificationModel = new Gson().fromJson(notificationString, targetClass);
+
+            if (notificationModel == null) {
+                throw (new Exception("BaseNotificationModel object could not be converted into " + Objects.requireNonNull(notificationTypes.get(baseNotificationModel.getType())).getName() + " object."));
+            }
+
+            return notificationModel;
+
+        }catch (Exception e){
+            throw e;
+        }
+    }
+
+    //// ACTION EVENTS
+
+    @ReactMethod
+    public void displayDialog(String notificationString) {
+
+        try {
+
+            BaseNotificationModel notificationModel = convertJSONToNotificationModel(notificationString);
+
+            try {
+                Objects.requireNonNull(getCurrentActivity()).runOnUiThread(() -> SmartMessage.getInstance().displayDialog(notificationModel));
+            } catch (Exception e) {
+                SMLogger.exception(e);
+            }
+
+            SMLogger.info(TAG, "success", "displayDialog");
+        } catch (Exception e) {
+            SMLogger.error(TAG, e.getMessage(), "displayDialog");
+        }
+
+    }
+
+    @ReactMethod
+    public void displayDialogWithPromise(String notificationString, Promise promise) {
+
+        if ( promise == null) {
+            return;
+        }
+
+        try {
+
+            BaseNotificationModel baseNotificationModel = convertJSONToNotificationModel(notificationString);
+
+            try {
+                Objects.requireNonNull(getCurrentActivity()).runOnUiThread(() -> SmartMessage.getInstance().displayDialog(baseNotificationModel));
+            } catch (Exception e) {
+                promise.reject(e);
+            }
+
+            promise.resolve(true);
+        } catch (Exception e) {
+            promise.reject(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void matchContactDevice(String matchContactRequestData){
+
+        try{
+
+            if(matchContactRequestData == null || matchContactRequestData.isEmpty()){
+                SMLogger.error(TAG, "matchContactRequest data is null or empty. Request won't be completed", "matchContactDevice");
+            }
+
+            MatchContactDeviceRequestBody matchContactDeviceRequestBody = new Gson().fromJson(matchContactRequestData, MatchContactDeviceRequestBody.class);
+
+            if(matchContactDeviceRequestBody == null)
+                SMLogger.error(TAG, "matchContactRequestData could not be parsed into a request object properly. Request won't be completed", "matchContactDevice");
+
+            SmartMessage.getInstance().matchContactDevice(matchContactDeviceRequestBody, new ResponseListener() {
+                @Override
+                public void onSuccess(BaseResponse response) {
+                    SMLogger.info(TAG, response.toJsonStr(), "matchContactDevice");
+                }
+
+                @Override
+                public void onError(String message) {
+                    SMLogger.error(TAG, message, "matchContactDevice");
+                }
+            });
+
+
+        }catch (Exception e){
+            SMLogger.exception(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void matchContactDeviceWithPromise(String matchContactRequestData, final Promise promise){
+
+        try{
+
+            if(matchContactRequestData == null || matchContactRequestData.isEmpty()){
+                promise.reject(new Exception("matchContactRequest data is null or empty. Request won't be completed"));
+            }
+
+            MatchContactDeviceRequestBody matchContactDeviceRequestBody = new Gson().fromJson(matchContactRequestData, MatchContactDeviceRequestBody.class);
+
+            if(matchContactDeviceRequestBody == null)
+                promise.reject(new Exception("matchContactRequestData could not be parsed into a request object properly. Request won't be completed"));
+
+            SmartMessage.getInstance().matchContactDevice(matchContactDeviceRequestBody, new ResponseListener() {
+                @Override
+                public void onSuccess(BaseResponse response) {
+                    promise.resolve(response.toJsonStr());
+                }
+
+                @Override
+                public void onError(String message) {
+                    promise.reject(new Throwable(message));
+                }
+            });
+
+
+        }catch (Exception e){
+            promise.reject(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void saveConfig(){
+
+        try{
+            SmartMessage.getInstance().saveConfig();
+        }catch(Exception e){
+            SMLogger.exception(e);
+        }
+    }
+
+    @ReactMethod
+    public void saveConfigWithPromise(final Promise promise){
+
+        try{
+            SmartMessage.getInstance().saveConfig();
+            BaseResponse baseResponseModel = new BaseResponse();
+            baseResponseModel.setExplanation("Config saved successfully");
+            baseResponseModel.setResponseCode(0);
+            baseResponseModel.setHttpStatusCode(0);
+            promise.resolve(baseResponseModel.toJsonStr());
+        }catch(Exception e){
+            promise.reject(e);
+        }
+    }
+
+    //// GETTER EVENTS
+
+    @ReactMethod
+    public void getMessageList(String data, final Promise promise) {
+
+        if (data == null || promise == null) {
+            return;
+        }
+
+        try {
+            final MessageListRequestBody messageListRequestBody = new Gson().fromJson(data, MessageListRequestBody.class);
+
+            if (messageListRequestBody == null) {
+                promise.reject(new Exception("Data string could not be converted into MessageListRequestBody object."));
+                return;
+            }
+
+            SmartMessage.getInstance().getMessageList(messageListRequestBody, new MessageListGetter.Listener() {
+                @Override
+                public void onSuccess(MessageListResponse messageListResponse) {
+                    String messageListResponseString = new Gson().toJson(messageListResponse);
+                    promise.resolve(messageListResponseString);
+                }
+
+                @Override
+                public void onError(String s) {
+                    promise.reject(new Exception(s));
+                }
+            });
+
+        } catch (Exception e) {
+            promise.reject(e);
+        }
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "RNSmartMessage";
+    }
+
+    @ReactMethod
+    public void getNotificationContent(String contentUrl,Promise promise) {
+
+        if (promise == null || contentUrl == null) {
+            return;
+        }
+
+        try{
+            SmartMessage.getInstance().getNotificationDetail(contentUrl,new StorageSender.StorageListener() {
+
+                @Override
+                public void onSuccess(BaseNotificationModel baseNotificationModel) {
+
+                    if(baseNotificationModel != null){
+                        promise.resolve(baseNotificationModel.toJsonStr());
+                    }
+
+                }
+
+                @Override
+                public void onError(String message) {
+                    promise.reject(new Exception(message));
+                }
+            });
+        }catch (Exception e){
+            promise.reject(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void getToken(final Promise promise) {
+
+        if (promise == null) {
+            return;
+        }
+
+        promise.resolve(SmartMessage.getInstance().getToken());
+
+    }
+
+    @ReactMethod
+    public void getUserInfo(final Promise promise) {
+
+        if (promise == null) {
+            return;
+        }
+
+        try{
+            SmartMessage.getInstance().getUserInfo(new UserInfoGetter.Listener() {
+                @Override
+                public void onSuccess(UserInfoResponse userInfoResponse) {
+                    try {
+                        String userInfoString = new Gson().toJson(userInfoResponse.getUserInfo());
+                        promise.resolve(userInfoString);
+                    } catch (Exception e) {
+                        promise.reject(e);
+                    }
+                }
+
+                @Override
+                public void onError(String message) {
+                    promise.reject(new Exception(message));
+                }
+
+                @Override
+                public void onSuccess(BaseResponse response) { }
+            });
+
+
+        }catch (Exception e){
+            promise.reject(e);
+        }
+
+    }
+
+    ////INBOX EVENTS
+    @ReactMethod
+    public void saveNotificationToDB(String baseNotificationJson,Boolean isSeen){
+
+        try{
+            BaseNotificationModel baseNotificationModel = convertJSONToNotificationModel(baseNotificationJson);
+            SmartMessage.getInstance().saveNotificationToDB(baseNotificationModel,isSeen);
+        }catch (Exception e){
+            SMLogger.exception(e);
+        }
+    }
+
+    @ReactMethod
+    public void getMessageListFromDB(final Promise promise){
+        try{
+
+            if(promise == null){
+                return;
+            }
+
+            SmartMessage.getInstance().getNotificationFromDB(new MessageDBListenerInterface() {
+                @Override
+                public void onReadSuccess(List<MessageEntity> messageEntityList) {
+                    promise.resolve(new Gson().toJson(messageEntityList));
+                }
+
+                @Override
+                public void onReadFail() {
+                    promise.reject(new Exception("There is no message or failed to get notification list from DB"));
+                }
+            });
+        }catch (Exception e){
+            promise.reject(e);
+        }
+    }
+
+    @ReactMethod
+    public void updateNotificationAsSeen(String notificationId) {
+
+        try {
+
+            if (notificationId == null) {
+                SMLogger.error(TAG, "notificationId is null.Request wont be completed", "updateNotificationAsSeen");
+            }
+
+            SmartMessage.getInstance().updateNotificationAsSeen(notificationId);
+        } catch (Exception e) {
+            SMLogger.exception(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void updateNotificationContent(String notificationId,String notificationString) {
+
+        try {
+
+            if (notificationString == null) {
+                SMLogger.error(TAG, "notificationString is null.Request wont be completed", "uploadNotificationContent");
+                return;
+            }
+
+            SmartMessage.getInstance().updateNotificationJsonString(notificationId,notificationString);
+
+        }catch (Exception e){
+            SMLogger.exception(e);
+        }
+
+    }
+
+    //// SETTER EVENTS
+    @ReactMethod
+    public void setUserInfo(final String data) {
+
+        try{
+            UserInfo userInfo = new Gson().fromJson(data, UserInfo.class);
+
+            if (userInfo == null) {
+                SMLogger.error(TAG,"Data string could not be converted into UserInfo object.","setUserInfo");
+                return;
+            }
+
+            SmartMessage.getInstance().setUserInfo(userInfo, new ResponseListener() {
+                @Override
+                public void onSuccess(BaseResponse response) {
+                    SMLogger.info(TAG,response.toJsonStr(), "setUserInfo");
+                }
+
+                @Override
+                public void onError(String message) {
+                    SMLogger.error(TAG, message, "setUserInfo");
+                }
+            });
+        }catch (Exception exception){
+            SMLogger.exception(exception);
+        }
+
+    }
+
+    @ReactMethod
+    public void setUserInfoWithPromise(final String data, final Promise promise) {
+
+        if (promise == null) {
+            return;
+        }
+
+        try{
+            UserInfo userInfo = new Gson().fromJson(data, UserInfo.class);
+
+            if (userInfo == null) {
+                promise.reject(new Exception("Data string could not be converted into UserInfo object."));
+                return;
+            }
+
+            SmartMessage.getInstance().setUserInfo(userInfo, new ResponseListener() {
+                @Override
+                public void onSuccess(BaseResponse response) {
+                    promise.resolve(response.toJsonStr());
+                }
+
+                @Override
+                public void onError(String message) {
+                    promise.reject(new Exception(message));
+                }
+            });
+
+        }catch (Exception exception){
+            promise.reject(exception);
+        }
+
+    }
+
+    //// REPORTING EVENTS
+    @ReactMethod
+    public void reportCustomEvent(String eventIdentifier, String uniqueId, String parameters) {
+
+        if( eventIdentifier == null || parameters == null || uniqueId == null){
+            SMLogger.error(TAG,"eventIdentifier , uniqueId or parameters cannot be null", "reportCustomEvent");
+            return;
+        }
+
+        try{
+            Type type = new TypeToken<HashMap<String, String>>() {}.getType();
+            HashMap<String, String> parametersMap = new Gson().fromJson(parameters, type);
+            SmartMessage.getInstance().reportCustomEvent(eventIdentifier, uniqueId, parametersMap, new ResponseListener() {
+                @Override
+                public void onSuccess(BaseResponse response) {
+                    SMLogger.info(TAG,response.toJsonStr(), "reportCustomEvent");
+                }
+
+                @Override
+                public void onError(String message) {
+                    SMLogger.error(TAG, message, "reportCustomEvent");
+                }
+            });
+        }catch (Exception e){
+            SMLogger.exception(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void reportCustomEventWithPromise(String eventIdentifier, String uniqueId, String parameters,final Promise promise) {
+
+        if (promise == null ) {
+            return;
+        }else if( eventIdentifier == null || parameters == null || uniqueId == null){
+            promise.reject(new Exception("in reportCustomEvent : eventIdentifier , uniqueId or parameters cannot be null.Request wont be completed"));
+            return;
+        }
+
+        try{
+            Type type = new TypeToken<HashMap<String, String>>() {}.getType();
+            HashMap<String, String> parametersMap = new Gson().fromJson(parameters, type);
+            SmartMessage.getInstance().reportCustomEvent(eventIdentifier, uniqueId, parametersMap, new ResponseListener() {
+                @Override
+                public void onSuccess(BaseResponse response) {
+                    promise.resolve(response.toJsonStr());
+                }
+
+                @Override
+                public void onError(String message) {
+                    promise.reject(new Exception(message));
+                }
+            });
+        }catch (Exception e){
+            promise.reject(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void reportLoggedInWithPromise(final Promise promise) {
+
+        if (promise == null) {
+            return;
+        }
+
+        try{
+            SmartMessage.getInstance().reportLoggedIn(new ResponseListener() {
+                @Override
+                public void onSuccess(BaseResponse response) {
+                    promise.resolve(response.toJsonStr());
+                }
+
+                @Override
+                public void onError(String message) {
+                    promise.reject(new Exception(message));
+                }
+            });
+        }catch (Exception e){
+            promise.reject(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void reportLoggedIn() {
+
+        try{
+
+            SmartMessage.getInstance().reportLoggedIn(new ResponseListener() {
+                @Override
+                public void onSuccess(BaseResponse response) {
+                    SMLogger.info(TAG,response.toJsonStr(), "reportLoggedIn");
+                }
+
+                @Override
+                public void onError(String message) {
+                    SMLogger.error(TAG,message, "reportLoggedIn");
+                }
+            });
+
+        }catch (Exception e){
+            SMLogger.exception(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void reportLoggedOut() {
+
+        try{
+            SmartMessage.getInstance().reportLoggedOut(new ResponseListener() {
+                @Override
+                public void onSuccess(BaseResponse response) {
+                    SMLogger.info(TAG,response.toJsonStr(), "reportLoggedOut");
+                }
+
+                @Override
+                public void onError(String message) {
+                    SMLogger.error(TAG,message, "reportLoggedOut");
+                }
+            });
+        }catch (Exception e){
+            SMLogger.exception(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void reportLoggedOutWithPromise(final Promise promise) {
+
+        if (promise == null) {
+            return;
+        }
+
+        try{
+            SmartMessage.getInstance().reportLoggedOut(new ResponseListener() {
+                @Override
+                public void onSuccess(BaseResponse response) {
+                    promise.resolve(response.toJsonStr());
+                }
+
+                @Override
+                public void onError(String message) {
+                    promise.reject(new Exception(message));
+                }
+            });
+        }catch (Exception e){
+            promise.reject(e);
+        }
+
+    }
+
+    //// PERMISSION EVENTS
+    @ReactMethod
+    public void permissionUpdate(String permissionType, boolean isGranted) {
+
+        if(permissionType == null || permissionType.isEmpty() ) {
+            SMLogger.error(TAG,"permissionType is null or empty.Request wont be completed","permissionUpdate");
+            return;
+        }
+
+        try {
+            PermissionType type = PermissionType.fromString(permissionType);
+            SmartMessage.getInstance().permissionUpdate(type, isGranted, new ResponseListener() {
+                @Override
+                public void onSuccess(BaseResponse response) {
+                    SMLogger.info(TAG, response.toJsonStr(),"permissionUpdate" );
+                }
+
+                @Override
+                public void onError(String message) {
+                    SMLogger.error(TAG, message, "permissionUpdate");
+                }
+            });
+        }catch (Exception e){
+            SMLogger.exception(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void permissionUpdateWithPromise(String permissionType, boolean isGranted,final Promise promise) {
+
+        if (promise == null ) {
+            return;
+        }
+
+        if(permissionType == null || permissionType.isEmpty() ) {
+            promise.reject(new Exception("permissionType is null or empty.Request wont be completed"));
+            return;
+        }
+
+        try {
+            PermissionType type = PermissionType.fromString(permissionType);
+            SmartMessage.getInstance().permissionUpdate(type, isGranted, new ResponseListener() {
+                @Override
+                public void onSuccess(BaseResponse response) {
+                    promise.resolve(response.toJsonStr());
+                }
+
+                @Override
+                public void onError(String message) {
+                    promise.reject(new Exception(message));
+                }
+            });
+        }catch (Exception e){
+            promise.reject(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void requestNotificationPermission() {
+
+        try{
+            SmartMessage.getInstance().requestNotificationPermissionWithActivity(isGranted -> SMLogger.info(TAG, isGranted ? "is granted" : "is denied", "requestNotificationPermission"));
+        }catch (Exception e){
+            SMLogger.exception(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void requestNotificationPermissionWithPromise(final Promise promise) {
+
+        try{
+
+            if(promise == null){
+                return;
+            }
+
+            SmartMessage.getInstance().requestNotificationPermissionWithActivity(promise::resolve);
+        }catch (Exception e){
+            promise.reject(e);
+        }
+
+    }
+
+    //// LOCATION EVENTS
+    @ReactMethod
+    public void requestLocationPermission() {
+        SmartMessage.getInstance().requestLocationPermissionWithActivity(isGranted -> SMLogger.info(TAG, isGranted ? "is granted" : "is denied", "requestLocationPermission"));
+    }
+
+    @ReactMethod
+    public void requestLocationPermissionWithPromise(final Promise promise) {
+
+        if(promise == null){
+            return;
+        }
+
+        SmartMessage.getInstance().requestLocationPermissionWithActivity(promise::resolve);
+    }
+
+    @ReactMethod
+    public void startLocationTracking() {
+
+        try{
+            SmartMessage.getInstance().startLocationTracking();
+        }catch (Exception e){
+            SMLogger.exception(e);
+        }
+
+    }
+
+    @ReactMethod
+    public void stopLocationTracking() {
+
+        try{
+            SmartMessage.getInstance().stopLocationTracking();
+        }catch (Exception e){
+            SMLogger.exception(e);
+        }
+    }
+
+}