Examples with ResultImageFile com.fanap.podchat.model.ResultImageFile used on opensource projects

Example 6 with ResultImageFile

use of com.fanap.podchat.model.ResultImageFile in project pod-chat-android-sdk by FanapSoft.

the class ChatCore method uploadImageProgress.

public String uploadImageProgress(RequestUploadImage request, @Nullable ProgressHandler.onProgress handler) {
    String uniqueId = generateUniqueId();
    if (needReadStoragePermission(request.getActivity())) {
        String jsonError = captureError(ChatConstant.ERROR_READ_EXTERNAL_STORAGE_PERMISSION, ChatConstant.ERROR_CODE_READ_EXTERNAL_STORAGE_PERMISSION, uniqueId);
        ErrorOutPut error = new ErrorOutPut(true, ChatConstant.ERROR_READ_EXTERNAL_STORAGE_PERMISSION, ChatConstant.ERROR_CODE_READ_EXTERNAL_STORAGE_PERMISSION, uniqueId);
        if (handler != null) {
            handler.onError(jsonError, error);
        }
        return uniqueId;
    }
    if (!chatReady) {
        onChatNotReady(uniqueId);
        return uniqueId;
    }
    if (getPodSpaceServer() == null) {
        captureError("File server is null", 0, uniqueId);
        return uniqueId;
    }
    try {
        Subscription subscription = PodUploader.uploadPublicToPodSpace(uniqueId, request.getFileUri(), context, getPodSpaceServer(), getToken(), TOKEN_ISSUER, String.valueOf(request.getxC()), String.valueOf(request.getyC()), String.valueOf(request.gethC()), String.valueOf(request.getwC()), request.isPublic(), new PodUploader.IPodUploadFileToPodSpace() {

            @Override
            public void onSuccess(UploadToPodSpaceResult response, File file, String mimeType, long length, int actualWidth, int actualHeight, int width, int height) {
                ChatResponse<ResultImageFile> chatResponse = PodUploader.generateImageUploadResultForSendMessage(response, uniqueId, actualWidth, actualHeight, width, height, getPodSpaceImageUrl(response.getHashCode()));
                String imageJson = gson.toJson(chatResponse);
                listenerManager.callOnUploadImageFile(imageJson, chatResponse);
                if (handler != null) {
                    handler.onFinish(imageJson, chatResponse);
                }
                showLog("RECEIVE_UPLOAD_IMAGE", imageJson);
            }

            @Override
            public void onFailure(String cause, Throwable t) {
                String jsonError = captureError(cause, ChatConstant.ERROR_CODE_UPLOAD_FILE, uniqueId, t);
                ErrorOutPut error = new ErrorOutPut(true, ChatConstant.ERROR_INVALID_FILE_URI, ChatConstant.ERROR_CODE_INVALID_FILE_URI, uniqueId);
                if (handler != null) {
                    handler.onError(jsonError, error);
                }
            }

            @Override
            public void onUploadStarted(String mimeType, File file, long length) {
                showLog("UPLOADING_FILE");
            }

            @Override
            public void onProgressUpdate(int progress, int totalBytesSent, int totalBytesToSend) {
                if (handler != null) {
                    handler.onProgressUpdate(progress);
                    handler.onProgressUpdate(uniqueId, progress, totalBytesSent, totalBytesToSend);
                }
            }
        });
        initCancelUpload(uniqueId, subscription);
    } catch (Exception e) {
        String jsonError = captureError(ChatConstant.ERROR_INVALID_FILE_URI, ChatConstant.ERROR_CODE_INVALID_FILE_URI, uniqueId, e);
        ErrorOutPut error = new ErrorOutPut(true, ChatConstant.ERROR_INVALID_FILE_URI, ChatConstant.ERROR_CODE_INVALID_FILE_URI, uniqueId);
        if (handler != null) {
            handler.onError(jsonError, error);
        }
    }
    return uniqueId;
}

Example 7 with ResultImageFile

use of com.fanap.podchat.model.ResultImageFile in project pod-chat-android-sdk by FanapSoft.

the class ChatCore method uploadImageToThread.

// new upload image function
private void uploadImageToThread(RequestUploadImage request, String userGroupHash, String uniqueId, @Nullable ProgressHandler.onProgress handler, OnWorkDone listener) {
    if (needReadStoragePermission(request.getActivity())) {
        String jsonError = captureError(ChatConstant.ERROR_READ_EXTERNAL_STORAGE_PERMISSION, ChatConstant.ERROR_CODE_READ_EXTERNAL_STORAGE_PERMISSION, uniqueId);
        ErrorOutPut error = new ErrorOutPut(true, ChatConstant.ERROR_READ_EXTERNAL_STORAGE_PERMISSION, ChatConstant.ERROR_CODE_READ_EXTERNAL_STORAGE_PERMISSION, uniqueId);
        if (handler != null) {
            handler.onError(jsonError, error);
        }
        listener.onWorkDone(null);
        return;
    }
    if (!chatReady) {
        onChatNotReady(uniqueId);
        listener.onWorkDone(null);
        return;
    }
    if (getPodSpaceServer() == null) {
        listener.onWorkDone(null);
        captureError("File server is null", 0, uniqueId);
        return;
    }
    try {
        Subscription subscription = PodUploader.uploadToPodSpace(uniqueId, request.getFileUri(), userGroupHash, context, getPodSpaceServer(), getToken(), TOKEN_ISSUER, String.valueOf(request.getxC()), String.valueOf(request.getyC()), String.valueOf(request.gethC()), String.valueOf(request.getwC()), new PodUploader.IPodUploadFileToPodSpace() {

            @Override
            public void onSuccess(UploadToPodSpaceResult response, File file, String mimeType, long length, int actualWidth, int actualHeight, int width, int height) {
                ChatResponse<ResultImageFile> chatResponse = PodUploader.generateImageUploadResultForSendMessage(response, uniqueId, actualWidth, actualHeight, width, height, getPodSpaceImageUrl(response.getHashCode()));
                String imageJson = gson.toJson(chatResponse);
                listenerManager.callOnUploadImageFile(imageJson, chatResponse);
                if (handler != null) {
                    handler.onFinish(imageJson, chatResponse);
                }
                showLog("RECEIVE_UPLOAD_IMAGE", imageJson);
                listener.onWorkDone(response.getHashCode());
            }

            @Override
            public void onFailure(String cause, Throwable t) {
                String jsonError = captureError(cause, ChatConstant.ERROR_CODE_UPLOAD_FILE, uniqueId, t);
                ErrorOutPut error = new ErrorOutPut(true, ChatConstant.ERROR_INVALID_FILE_URI, ChatConstant.ERROR_CODE_INVALID_FILE_URI, uniqueId);
                if (handler != null) {
                    handler.onError(jsonError, error);
                }
                listener.onWorkDone(null);
            }

            @Override
            public void onUploadStarted(String mimeType, File file, long length) {
                showLog("UPLOADING_FILE");
            }

            @Override
            public void onProgressUpdate(int progress, int totalBytesSent, int totalBytesToSend) {
                if (handler != null) {
                    handler.onProgressUpdate(progress);
                    handler.onProgressUpdate(uniqueId, progress, totalBytesSent, totalBytesToSend);
                }
            }
        });
        initCancelUpload(uniqueId, subscription);
    } catch (Exception e) {
        String jsonError = captureError(ChatConstant.ERROR_INVALID_FILE_URI, ChatConstant.ERROR_CODE_INVALID_FILE_URI, uniqueId, e);
        ErrorOutPut error = new ErrorOutPut(true, ChatConstant.ERROR_INVALID_FILE_URI, ChatConstant.ERROR_CODE_INVALID_FILE_URI, uniqueId);
        listener.onWorkDone(null);
        if (handler != null) {
            handler.onError(jsonError, error);
        }
    }
}

Example 8 with ResultImageFile

use of com.fanap.podchat.model.ResultImageFile in project pod-chat-android-sdk by FanapSoft.

the class ChatCore method replyFileMessage.

/**
 * Reply the message in the current thread and send az message and receive at the
 * <p>
 * messageContent content of the reply message
 * threadId       id of the thread
 * messageId      of the message that we want to reply
 * metaData       meta data of the message
 */
public String replyFileMessage(RequestReplyFileMessage request, ProgressHandler.sendFileMessage handler) {
    String uniqueId = generateUniqueId();
    if (needReadStoragePermission(request.getActivity())) {
        String jsonError = captureError(ChatConstant.ERROR_READ_EXTERNAL_STORAGE_PERMISSION, ChatConstant.ERROR_CODE_READ_EXTERNAL_STORAGE_PERMISSION, uniqueId);
        ErrorOutPut error = new ErrorOutPut(true, ChatConstant.ERROR_READ_EXTERNAL_STORAGE_PERMISSION, ChatConstant.ERROR_CODE_READ_EXTERNAL_STORAGE_PERMISSION, uniqueId);
        if (handler != null) {
            handler.onError(jsonError, error);
        }
        return uniqueId;
    }
    if (!chatReady) {
        onChatNotReady(uniqueId);
        return uniqueId;
    }
    if (getPodSpaceServer() == null) {
        captureError("PodSpace server is null", 0, uniqueId);
        return uniqueId;
    }
    long threadId = request.getThreadId();
    String messageContent = request.getMessageContent();
    String systemMetaData = request.getSystemMetaData();
    Uri fileUri = request.getFileUri();
    long messageId = request.getMessageId();
    int messageType = request.getMessageType();
    String methodName = ChatConstant.METHOD_REPLY_MSG;
    try {
        Subscription subscription = PodUploader.uploadToPodSpace(uniqueId, request.getFileUri(), request.getUserGroupHashCode(), context, getPodSpaceServer(), getToken(), TOKEN_ISSUER, request.getImageXc(), request.getImageYc(), request.getImageHc(), request.getImageWc(), new PodUploader.IPodUploadFileToPodSpace() {

            @Override
            public void onSuccess(UploadToPodSpaceResult response, File file, String mimeType, long length) {
                removeFromUploadQueue(uniqueId);
                ChatResponse<ResultFile> chatResponse = PodUploader.generateImageUploadResultForSendMessage(response, uniqueId);
                String json = gson.toJson(chatResponse);
                showLog("FILE_UPLOADED_TO_SERVER", json);
                listenerManager.callOnUploadFile(json, chatResponse);
                if (handler != null) {
                    handler.onFinishFile(json, chatResponse);
                }
                String jsonMeta = createFileMetadata(file, response.getHashCode(), 0, mimeType, length, response.getParentHash());
                showLog("SEND_REPLY_FILE_MESSAGE", jsonMeta);
                mainReplyMessage(messageContent, threadId, messageId, systemMetaData, messageType, jsonMeta, uniqueId, null);
            }

            @Override
            public void onSuccess(UploadToPodSpaceResult response, File file, String mimeType, long length, int actualWidth, int actualHeight, int width, int height) {
                removeFromUploadQueue(uniqueId);
                ChatResponse<ResultImageFile> chatResponse = PodUploader.generateImageUploadResultForSendMessage(response, uniqueId, actualWidth, actualHeight, width, height, getPodSpaceImageUrl(response.getHashCode()));
                String imageJson = gson.toJson(chatResponse);
                listenerManager.callOnUploadImageFile(imageJson, chatResponse);
                if (handler != null) {
                    handler.onFinishImage(imageJson, chatResponse);
                }
                showLog("RECEIVE_UPLOAD_IMAGE", imageJson);
                String jsonMeta = createImageMetadata(file, response.getHashCode(), 0, height, width, mimeType, length, response.getParentHash(), false, null);
                showLog("SEND_REPLY_FILE_MESSAGE", jsonMeta);
                mainReplyMessage(messageContent, threadId, messageId, systemMetaData, messageType, jsonMeta, uniqueId, null);
            }

            @Override
            public void onFailure(String cause, Throwable t) {
                String jsonError = captureError(cause, ChatConstant.ERROR_CODE_UPLOAD_FILE, uniqueId, t);
                ErrorOutPut error = new ErrorOutPut(true, ChatConstant.ERROR_INVALID_FILE_URI, ChatConstant.ERROR_CODE_INVALID_FILE_URI, uniqueId);
                if (handler != null) {
                    handler.onError(jsonError, error);
                }
            }

            @Override
            public void onUploadStarted(String mimeType, File file, long length) {
                addToUploadQueue(messageContent, fileUri, messageType, threadId, request.getUserGroupHashCode(), uniqueId, systemMetaData, messageId, mimeType, null, methodName, file, length);
                showLog("UPLOAD_FILE_TO_SERVER");
            }

            @Override
            public void onProgressUpdate(int progress, int totalBytesSent, int totalBytesToSend) {
                if (handler != null)
                    handler.onProgressUpdate(uniqueId, progress, totalBytesSent, totalBytesToSend);
            }
        });
        initCancelUpload(uniqueId, subscription);
    } catch (Exception e) {
        String jsonError = captureError(ChatConstant.ERROR_INVALID_FILE_URI, ChatConstant.ERROR_CODE_INVALID_FILE_URI, uniqueId, e);
        ErrorOutPut error = new ErrorOutPut(true, ChatConstant.ERROR_INVALID_FILE_URI, ChatConstant.ERROR_CODE_INVALID_FILE_URI, uniqueId);
        if (handler != null) {
            handler.onError(jsonError, error);
        }
    }
    return uniqueId;
}

Example 9 with ResultImageFile

use of com.fanap.podchat.model.ResultImageFile in project pod-chat-android-sdk by FanapSoft.

the class ChatCore method mainMapStaticImage.

private String mainMapStaticImage(RequestLocationMessage request, Activity activity, String uniqueId, boolean isMessage, ProgressHandler.sendFileMessage handler) {
    try {
        if (Util.isNullOrEmpty(uniqueId)) {
            uniqueId = generateUniqueId();
        }
        if (needReadStoragePermission(activity))
            return uniqueId;
        if (chatReady) {
            JsonObject jsonLog = new JsonObject();
            String type = request.getType();
            int zoom = request.getZoom();
            int width = request.getWidth();
            int height = request.getHeight();
            String center = request.getCenter();
            long threadId = request.getThreadId();
            int messageType = request.getMessageType() > 0 ? request.getMessageType() : TextMessageType.Constants.POD_SPACE_PICTURE;
            String systemMetadata = request.getSystemMetadata();
            if (Util.isNullOrEmpty(type)) {
                type = "standard-night";
            }
            if (Util.isNullOrEmpty(zoom)) {
                zoom = 15;
            }
            if (Util.isNullOrEmpty(width)) {
                width = 800;
            }
            if (Util.isNullOrEmpty(height)) {
                height = 500;
            }
            RetrofitHelperMap retrofitHelperMap = new RetrofitHelperMap("https://api.neshan.org/");
            MapApi mapApi = retrofitHelperMap.getService(MapApi.class);
            Call<ResponseBody> call = mapApi.mapStaticCall(API_KEY_MAP, type, zoom, center, width, height);
            String finalUniqueId = uniqueId;
            jsonLog.addProperty("type", type);
            jsonLog.addProperty("zoom", zoom);
            jsonLog.addProperty("width", width);
            jsonLog.addProperty("height", height);
            jsonLog.addProperty("center", center);
            jsonLog.addProperty("threadId", threadId);
            jsonLog.addProperty("messageType", messageType);
            jsonLog.addProperty("systemMetadata", systemMetadata);
            jsonLog.addProperty("uniqueId", uniqueId);
            showLog("SEND_LOCATION_MESSAGE", getJsonForLog(jsonLog));
            call.enqueue(new retrofit2.Callback<ResponseBody>() {

                @Override
                public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                    if (response.isSuccessful()) {
                        if (response.body() != null) {
                            Bitmap bitmap = BitmapFactory.decodeStream(response.body().byteStream());
                            ChatResponse<ResultStaticMapImage> chatResponse = new ChatResponse<>();
                            ResultStaticMapImage result = new ResultStaticMapImage();
                            result.setBitmap(bitmap);
                            chatResponse.setUniqueId(finalUniqueId);
                            chatResponse.setResult(result);
                            listenerManager.callOnStaticMap(chatResponse);
                            showLog("RECEIVE_MAP_STATIC");
                            if (!call.isCanceled()) {
                                call.cancel();
                            }
                            if (isMessage) {
                                File file = null;
                                try {
                                    file = FileUtils.saveBitmap(bitmap, "map");
                                } catch (Exception e) {
                                    captureError(ChatConstant.ERROR_WRITING_FILE, ChatConstant.ERROR_CODE_WRITING_FILE, finalUniqueId, e);
                                }
                                if (file == null) {
                                    captureError(ChatConstant.ERROR_WRITING_FILE, ChatConstant.ERROR_CODE_WRITING_FILE, finalUniqueId);
                                    return;
                                }
                                Uri fileUri = Uri.fromFile(file);
                                if (!chatReady) {
                                    onChatNotReady(finalUniqueId);
                                    return;
                                }
                                if (getPodSpaceServer() == null) {
                                    captureError("PodSpace server is null", 0, finalUniqueId);
                                    return;
                                }
                                removeFromUploadQueue(finalUniqueId);
                                try {
                                    Subscription subscription = PodUploader.uploadToPodSpace(finalUniqueId, fileUri, request.getUserGroupHash(), context, getPodSpaceServer(), getToken(), TOKEN_ISSUER, new PodUploader.IPodUploadFileToPodSpace() {

                                        @Override
                                        public void onSuccess(UploadToPodSpaceResult response, File file, String mimeType, long length, int actualWidth, int actualHeight, int width, int height) {
                                            removeFromUploadQueue(finalUniqueId);
                                            ChatResponse<ResultImageFile> chatResponse = PodUploader.generateImageUploadResultForSendMessage(response, finalUniqueId, actualWidth, actualHeight, width, height, getPodSpaceImageUrl(response.getHashCode()));
                                            String imageJson = gson.toJson(chatResponse);
                                            listenerManager.callOnUploadImageFile(imageJson, chatResponse);
                                            if (handler != null) {
                                                handler.onFinishImage(imageJson, chatResponse);
                                            }
                                            showLog("RECEIVE_UPLOAD_IMAGE", imageJson);
                                            String jsonMeta = createImageMetadata(file, response.getHashCode(), 0, height, width, mimeType, length, response.getParentHash(), false, null);
                                            sendTextMessageWithFile(request.getMessage(), threadId, jsonMeta, systemMetadata, finalUniqueId, typeCode, messageType);
                                        }

                                        @Override
                                        public void onFailure(String cause, Throwable t) {
                                            String jsonError = captureError(cause, ChatConstant.ERROR_CODE_UPLOAD_FILE, finalUniqueId, t);
                                            ErrorOutPut error = new ErrorOutPut(true, ChatConstant.ERROR_INVALID_FILE_URI, ChatConstant.ERROR_CODE_INVALID_FILE_URI, finalUniqueId);
                                            if (handler != null) {
                                                handler.onError(jsonError, error);
                                            }
                                        }

                                        @Override
                                        public void onUploadStarted(String mimeType, File file, long length) {
                                            addToUploadQueue(request.getMessage(), fileUri, messageType, threadId, request.getUserGroupHash(), finalUniqueId, systemMetadata, request.getMessageId(), mimeType, request.getCenter(), ChatConstant.METHOD_LOCATION_MSG, file, length);
                                            showLog("UPLOAD_FILE_TO_SERVER");
                                        }

                                        @Override
                                        public void onProgressUpdate(int progress, int totalBytesSent, int totalBytesToSend) {
                                            if (handler != null)
                                                handler.onProgressUpdate(finalUniqueId, progress, totalBytesSent, totalBytesToSend);
                                        }
                                    });
                                    initCancelUpload(finalUniqueId, subscription);
                                } catch (Exception e) {
                                    String jsonError = captureError(ChatConstant.ERROR_INVALID_FILE_URI, ChatConstant.ERROR_CODE_INVALID_FILE_URI, finalUniqueId, e);
                                    ErrorOutPut error = new ErrorOutPut(true, ChatConstant.ERROR_INVALID_FILE_URI, ChatConstant.ERROR_CODE_INVALID_FILE_URI, finalUniqueId);
                                    if (handler != null) {
                                        handler.onError(jsonError, error);
                                    }
                                }
                            }
                        }
                    } else {
                        captureError(ChatConstant.ERROR_CALL_NESHAN_API, ChatConstant.ERROR_CODE_CALL_NESHAN_API, finalUniqueId);
                        showErrorLog(response.message());
                    }
                }

                @Override
                public void onFailure(Call<ResponseBody> call, Throwable t) {
                    captureError(t.getMessage(), ChatConstant.ERROR_CODE_UNKNOWN_EXCEPTION, finalUniqueId, t);
                }
            });
        } else {
            captureError(ChatConstant.ERROR_CHAT_READY, ChatConstant.ERROR_CODE_CHAT_READY, uniqueId);
        }
    } catch (Throwable throwable) {
        showErrorLog(throwable.getMessage());
        onUnknownException(uniqueId, throwable);
    }
    return uniqueId;
}

Example 10 with ResultImageFile

use of com.fanap.podchat.model.ResultImageFile in project pod-chat-android-sdk by FanapSoft.

the class ChatCore method mainUploadImageFileMsg.

private void mainUploadImageFileMsg(LFileUpload fileUpload) {
    JsonObject jsonLog = new JsonObject();
    String description = fileUpload.getDescription();
    jsonLog.addProperty("description", description);
    ProgressHandler.sendFileMessage handler = fileUpload.getHandler();
    Integer messageType = fileUpload.getMessageType();
    jsonLog.addProperty("messageType", messageType);
    long threadId = fileUpload.getThreadId();
    jsonLog.addProperty("threadId", threadId);
    String uniqueId = fileUpload.getUniqueId();
    jsonLog.addProperty("uniqueId", uniqueId);
    String systemMetaData = fileUpload.getSystemMetaData();
    jsonLog.addProperty("systemMetaData", systemMetaData);
    long messageId = fileUpload.getMessageId();
    jsonLog.addProperty("messageId", messageId);
    String mimeType = fileUpload.getMimeType();
    jsonLog.addProperty("mimeType", mimeType);
    String methodName = fileUpload.getMethodName();
    jsonLog.addProperty("methodName", methodName);
    long fileSize = fileUpload.getFileSize();
    jsonLog.addProperty("fileSize", fileSize);
    String center = fileUpload.getCenter();
    jsonLog.addProperty("center", center);
    File file = fileUpload.getFile();
    if (chatReady) {
        if (fileServer != null) {
            RetrofitHelperFileServer retrofitHelperFileServer = new RetrofitHelperFileServer(getFileServer());
            FileApi fileApi = retrofitHelperFileServer.getService(FileApi.class);
            try {
                showLog("UPLOAD_FILE_TO_SERVER", getJsonForLog(jsonLog));
            } catch (Exception e) {
                showErrorLog(e.getMessage());
            }
            ProgressRequestBody requestFile = new ProgressRequestBody(file, mimeType, uniqueId, new ProgressRequestBody.UploadCallbacks() {

                @Override
                public void onProgress(String uniqueId, int progress, int totalBytesSent, int totalBytesToSend) {
                    Log.i(TAG, "on progress");
                    if (handler != null) {
                        handler.onProgressUpdate(uniqueId, progress, totalBytesSent, totalBytesToSend);
                        if (log)
                            Log.i(TAG, "uniqueId " + uniqueId + " bytesSent " + progress);
                    } else {
                        if (log)
                            Log.i(TAG, "Handler is null");
                    }
                }

                @Override
                public void onError() {
                    if (log)
                        Log.i(TAG, "Error on upload");
                }

                @Override
                public void onFinish() {
                    if (log)
                        Log.i(TAG, "Finish upload");
                }
            });
            MultipartBody.Part body = MultipartBody.Part.createFormData("image", file.getName(), requestFile);
            RequestBody name = RequestBody.create(MediaType.parse("text/plain"), file.getName());
            Observable<Response<FileImageUpload>> uploadObservable = fileApi.sendImageFile(body, getToken(), TOKEN_ISSUER, name);
            Subscription subscribe = uploadObservable.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(fileUploadResponse -> {
                if (fileUploadResponse.body() != null && fileUploadResponse.isSuccessful()) {
                    boolean hasError = fileUploadResponse.body().isHasError();
                    if (hasError) {
                        String errorMessage = fileUploadResponse.body().getMessage();
                        int errorCode = fileUploadResponse.body().getErrorCode();
                        String jsonError = captureError(errorMessage, errorCode, uniqueId);
                        // listenerManager.callOnLogEvent(jsonError);
                        ErrorOutPut error = new ErrorOutPut(true, errorMessage, errorCode, uniqueId);
                        if (handler != null) {
                            handler.onError(jsonError, error);
                        }
                    } else {
                        // remove from Uploading Queue
                        removeFromUploadQueue(uniqueId);
                        ResultImageFile result = fileUploadResponse.body().getResult();
                        long imageId = result.getId();
                        String hashCode = result.getHashCode();
                        ChatResponse<ResultImageFile> chatResponse = new ChatResponse<>();
                        ResultImageFile resultImageFile = new ResultImageFile();
                        chatResponse.setUniqueId(uniqueId);
                        resultImageFile.setId(result.getId());
                        resultImageFile.setHashCode(result.getHashCode());
                        resultImageFile.setName(result.getName());
                        resultImageFile.setHeight(result.getHeight());
                        resultImageFile.setWidth(result.getWidth());
                        resultImageFile.setActualHeight(result.getActualHeight());
                        resultImageFile.setActualWidth(result.getActualWidth());
                        chatResponse.setResult(resultImageFile);
                        String imageJson = gson.toJson(chatResponse);
                        listenerManager.callOnUploadImageFile(imageJson, chatResponse);
                        if (handler != null) {
                            handler.onFinishImage(imageJson, chatResponse);
                        }
                        showLog("RECEIVE_UPLOAD_IMAGE", imageJson);
                        // if (log) Log.i(TAG, "RECEIVE_UPLOAD_IMAGE");
                        // listenerManager.callOnLogEvent(imageJson);
                        String metaJson;
                        if (!Util.isNullOrEmpty(methodName) && methodName.equals(ChatConstant.METHOD_LOCATION_MSG)) {
                            metaJson = createImageMetadata(file, hashCode, imageId, result.getActualHeight(), result.getActualWidth(), mimeType, fileSize, null, true, center);
                        } else {
                            metaJson = createImageMetadata(file, hashCode, imageId, result.getActualHeight(), result.getActualWidth(), mimeType, fileSize, null, false, null);
                        }
                        // 
                        JsonObject js = new JsonObject();
                        js.addProperty("metadata", metaJson);
                        js.addProperty("uniqueId", uniqueId);
                        // send to handler
                        if (handler != null) {
                            handler.onFinishImage(imageJson, chatResponse);
                        }
                        if (isReplyMessage(methodName)) {
                            showLog("SEND_REPLY_FILE_MESSAGE", getJsonForLog(js));
                            mainReplyMessage(description, threadId, messageId, systemMetaData, messageType, metaJson, uniqueId, null);
                        // if (log) Log.i(TAG, "SEND_REPLY_FILE_MESSAGE");
                        // listenerManager.callOnLogEvent(metaJson);
                        } else {
                            sendTextMessageWithFile(description, threadId, metaJson, systemMetaData, uniqueId, typeCode, messageType);
                        }
                    // listenerManager.callOnLogEvent(metaJson);
                    }
                }
            }, throwable -> {
                try {
                    String jsonError = captureError(throwable.getMessage(), ChatConstant.ERROR_CODE_UNKNOWN_EXCEPTION, uniqueId);
                    ErrorOutPut error = new ErrorOutPut(true, throwable.getMessage(), ChatConstant.ERROR_CODE_UNKNOWN_EXCEPTION, uniqueId);
                    if (log)
                        Log.e(TAG, jsonError);
                    if (handler != null) {
                        handler.onError(jsonError, error);
                    }
                } catch (Exception e) {
                    showErrorLog(e.getMessage());
                    onUnknownException(uniqueId, e);
                }
            });
            /*
                 * Cancel Upload request
                 * */
            initCancelUpload(uniqueId, subscribe);
        } else {
            if (log)
                Log.e(TAG, "FileServer url Is null");
        }
    } else {
        captureError(ChatConstant.ERROR_CHAT_READY, ChatConstant.ERROR_CODE_CHAT_READY, uniqueId);
    }
}