请问下 发送大文件的时候 在上传文件的时候 怎么在聊天界面先展示一个带进度条的消息，然后发送成功后更新消息状态。 我目前已经实现将图片视频文档等文件上传到阿里oss了，但是要文件完全上传完成聊天界面才更新，怎么样在上传文件之前先在聊天界面展示一个带进度条的消息。这是我目前ChatManager的代码

public void sendMessage(final Message msg, final int expireDuration, final SendMessageCallback callback) {
        msg.direction = MessageDirection.Send;
        msg.status = MessageStatus.Sending;
        msg.serverTime = System.currentTimeMillis();
        msg.sender = userId;
        msg.messageUid = 0;
        if (!checkRemoteService()) {
            if (callback != null) {
                msg.status = MessageStatus.Send_Failure;
                callback.onFail(ErrorCode.SERVICE_DIED);
            }
            for (OnSendMessageListener listener : sendMessageListeners) {
                listener.onSendFail(msg, ErrorCode.SERVICE_DIED);
            }
            return;
        }

        MediaMessageUploadCallback mediaMessageUploadCallback = null;
        if (msg.content instanceof MediaMessageContent || (msg.content instanceof RawMessageContent && !TextUtils.isEmpty(((RawMessageContent) msg.content).payload.localMediaPath))) {
            String remoteUrl;
            String localPath;
            if (msg.content instanceof MediaMessageContent) {
                remoteUrl = ((MediaMessageContent) msg.content).remoteUrl;
                localPath = ((MediaMessageContent) msg.content).localPath;
            } else {
                remoteUrl = ((RawMessageContent) msg.content).payload.remoteMediaUrl;
                localPath = ((RawMessageContent) msg.content).payload.localMediaPath;
            }

            if (TextUtils.isEmpty(remoteUrl)) {
                if (!TextUtils.isEmpty(localPath)) {
                    File file = new File(localPath);
                    if (!file.exists()) {
                        if (callback != null) {
                            callback.onFail(ErrorCode.FILE_NOT_EXIST);
                        }
                        return;
                    }

                    // 上传文件到 OSS
                    OssUploader.uploadFile(gContext, file, new OssUploadCallback() {
                        @Override
                        public void onSuccess(String finalUrl) {
                            Log.d("OSS", "上传成功：" + finalUrl);

                            // 设置消息的远程 URL
                            if (msg.content instanceof MediaMessageContent) {
                                ((MediaMessageContent) msg.content).remoteUrl = finalUrl;
                            } else if (msg.content instanceof RawMessageContent) {
                                ((RawMessageContent) msg.content).payload.remoteMediaUrl = finalUrl;
                            }

                            // 上传完成后，继续原来的发送逻辑
                            sendAfterUpload(msg, expireDuration, callback);
                        }

                        @Override
                        public void onFailure(Exception e) {
                            Log.e("OSS", "上传失败：" + e.getMessage());
                            msg.status = MessageStatus.Send_Failure;

                            // 回调失败
                            mainHandler.post(() -> {
                                if (callback != null) callback.onFail(ErrorCode.UPLOAD_FAILED);
                                for (OnSendMessageListener listener : sendMessageListeners) {
                                    listener.onSendFail(msg, ErrorCode.UPLOAD_FAILED);
                                }
                            });
                        }

                        @Override
                        public void onProgress(long current, long total) {
                            // 回调上传进度
                            mainHandler.post(() -> {
                                if (callback != null) callback.onProgress(current, total);
                                for (OnSendMessageListener listener : sendMessageListeners) {
                                    listener.onProgress(msg, current, total);
                                }
                            });
                        }
                    });

                    return;

                }
            }
        } else if (sendLogCommand != null && (msg.content instanceof TextMessageContent || (rawMsg && msg.content instanceof RawMessageContent))) {
            String text = "";
            if (msg.content instanceof TextMessageContent) {
                text = ((TextMessageContent) msg.content).getContent();
            } else if (msg.content instanceof RawMessageContent) {
                text = ((RawMessageContent) msg.content).payload.searchableContent;
            }

            if (sendLogCommand.equals(text)) {
                if (!startLog) {
                    ((TextMessageContent) msg.content).setContent("未开启日志，无法发送日志");
                } else {
                    List<String> logFilesPath = getLogFilesPath();
                    if (!logFilesPath.isEmpty()) {
                        FileMessageContent fileMessageContent = new FileMessageContent(logFilesPath.get(logFilesPath.size() - 1));
                        msg.content = fileMessageContent;

                        mediaMessageUploadCallback = new MediaMessageUploadCallback() {
                            @Override
                            public void onMediaMessageUploaded(String remoteUrl) {
                                TextMessageContent textMessageContent = new TextMessageContent(remoteUrl);
                                sendMessage(msg.conversation, textMessageContent, null, 0, null);
                            }
                        };
                    } else {
                        ((TextMessageContent) msg.content).setContent("日志为空，无法发送日志");
                    }
                }
            }
        }

        try {
            MediaMessageUploadCallback finalMediaMessageUploadCallback = mediaMessageUploadCallback;
            mClient.send(msg, new cn.wildfirechat.client.ISendMessageCallback.Stub() {
                @Override
                public void onSuccess(final long messageUid, final long timestamp) throws RemoteException {
                    msg.messageUid = messageUid;
                    msg.serverTime = timestamp;
                    msg.status = MessageStatus.Sent;
                    if (msg.content instanceof MediaMessageContent && urlRedirector != null) {
                        String remoteUrl = ((MediaMessageContent) msg.content).remoteUrl;
                        ((MediaMessageContent) msg.content).remoteUrl = urlRedirector.urlRedirect(remoteUrl);
                    }
                    mainHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            if (callback != null) {
                                callback.onSuccess(messageUid, timestamp);
                            }
                            for (OnSendMessageListener listener : sendMessageListeners) {
                                listener.onSendSuccess(msg);
                            }
                        }
                    });
                }

                @Override
                public void onFailure(final int errorCode) throws RemoteException {
                    msg.status = MessageStatus.Send_Failure;
                    mainHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            if (callback != null) {
                                callback.onFail(errorCode);
                            }
                            for (OnSendMessageListener listener : sendMessageListeners) {
                                listener.onSendFail(msg, errorCode);
                            }
                        }
                    });
                }

                @Override
                public void onPrepared(final long messageId, final long savedTime) throws RemoteException {
                    msg.messageId = messageId;
                    msg.serverTime = savedTime;
                    mainHandler.post(() -> {
                        if (callback != null) {
                            callback.onPrepare(messageId, savedTime);
                        }
                        for (OnSendMessageListener listener : sendMessageListeners) {
                            listener.onSendPrepare(msg, savedTime);
                        }
                    });
                }

                @Override
                public void onProgress(final long uploaded, final long total) throws RemoteException {
                    if (callback != null) {
                        mainHandler.post(() -> callback.onProgress(uploaded, total));
                    }

                    mainHandler.post(() -> {
                        for (OnSendMessageListener listener : sendMessageListeners) {
                            listener.onProgress(msg, uploaded, total);
                        }
                    });
                }

                @Override
                public void onMediaUploaded(final String remoteUrl) throws RemoteException {
                    if (msg.content instanceof MediaMessageContent) {
                        MediaMessageContent mediaMessageContent = (MediaMessageContent) msg.content;
                        mediaMessageContent.remoteUrl = remoteUrl;
                    } else if (msg.content instanceof RawMessageContent) {
                        RawMessageContent rawMessageContent = (RawMessageContent) msg.content;
                        rawMessageContent.payload.remoteMediaUrl = remoteUrl;
                    }
                    if (msg.messageId == 0) {
                        return;
                    }

                    if (finalMediaMessageUploadCallback != null) {
                        finalMediaMessageUploadCallback.onMediaMessageUploaded(remoteUrl);
                    }

                    if (callback != null) {
                        mainHandler.post(() -> callback.onMediaUpload(remoteUrl));
                    }
                    mainHandler.post(() -> {
                        for (OnSendMessageListener listener : sendMessageListeners) {
                            listener.onMediaUpload(msg, remoteUrl);
                        }
                    });
                }
            }, expireDuration);
        } catch (RemoteException e) {
            e.printStackTrace();
            if (callback != null) {
                msg.status = MessageStatus.Send_Failure;
                mainHandler.post(() -> callback.onFail(ErrorCode.SERVICE_EXCEPTION));
            }
            mainHandler.post(() -> {
                for (OnSendMessageListener listener : sendMessageListeners) {
                    listener.onSendFail(msg, ErrorCode.SERVICE_EXCEPTION);
                }
            });
        }
    }

    private void sendAfterUpload(Message msg, int expireDuration, SendMessageCallback callback) {
        try {
            mClient.send(msg, new cn.wildfirechat.client.ISendMessageCallback.Stub() {
                @Override
                public void onSuccess(long messageUid, long timestamp) throws RemoteException {
                    msg.messageUid = messageUid;
                    msg.serverTime = timestamp;
                    msg.status = MessageStatus.Sent;
                    mainHandler.post(() -> {
                        if (callback != null) callback.onSuccess(messageUid, timestamp);
                        for (OnSendMessageListener listener : sendMessageListeners) {
                            listener.onSendSuccess(msg);
                        }
                    });
                }

                @Override
                public void onFailure(int errorCode) throws RemoteException {
                    msg.status = MessageStatus.Send_Failure;
                    mainHandler.post(() -> {
                        if (callback != null) callback.onFail(errorCode);
                        for (OnSendMessageListener listener : sendMessageListeners) {
                            listener.onSendFail(msg, errorCode);
                        }
                    });
                }

                @Override
                public void onPrepared(long messageId, long savedTime) throws RemoteException {
                    msg.messageId = messageId;
                    msg.serverTime = savedTime;
                    mainHandler.post(() -> {
                        if (callback != null) callback.onPrepare(messageId, savedTime);
                        for (OnSendMessageListener listener : sendMessageListeners) {
                            listener.onSendPrepare(msg, savedTime);
                        }
                    });
                }

                @Override
                public void onProgress(long uploaded, long total) throws RemoteException {
                    if (callback != null) mainHandler.post(() -> callback.onProgress(uploaded, total));
                    mainHandler.post(() -> {
                        for (OnSendMessageListener listener : sendMessageListeners) {
                            listener.onProgress(msg, uploaded, total);
                        }
                    });
                }

                @Override
                public void onMediaUploaded(String remoteUrl) throws RemoteException {
                    // 如果底层再次触发 onMediaUploaded，也同步更新
                    if (msg.content instanceof MediaMessageContent) {
                        ((MediaMessageContent) msg.content).remoteUrl = remoteUrl;
                    } else if (msg.content instanceof RawMessageContent) {
                        ((RawMessageContent) msg.content).payload.remoteMediaUrl = remoteUrl;
                    }

                    mainHandler.post(() -> {
                        if (callback != null) callback.onMediaUpload(remoteUrl);
                        for (OnSendMessageListener listener : sendMessageListeners) {
                            listener.onMediaUpload(msg, remoteUrl);
                        }
                    });
                }
            }, expireDuration);
        } catch (RemoteException e) {
            e.printStackTrace();
            msg.status = MessageStatus.Send_Failure;
            mainHandler.post(() -> {
                if (callback != null) callback.onFail(ErrorCode.SERVICE_EXCEPTION);
                for (OnSendMessageListener listener : sendMessageListeners) {
                    listener.onSendFail(msg, ErrorCode.SERVICE_EXCEPTION);
                }
            });
        }
    }