edoctor-sendbird-calls 1.0.0

package/android/src/main/java/com/edoctorsendbirdcalls/RNSendBirdCallsModule.java

@@ -0,0 +1,2068 @@
+// // RNSendBirdCallsModule.java
+
+// package com.rnsendbirdcalls;
+
+// import android.annotation.SuppressLint;
+// import android.content.Context;
+// import android.content.Intent;
+// import android.content.SharedPreferences;
+// import android.os.Build;
+// import android.os.Bundle;
+// import android.os.Environment;
+// import android.util.Log;
+
+// import androidx.annotation.NonNull;
+// import androidx.annotation.Nullable;
+
+// import com.facebook.react.bridge.Arguments;
+// import com.facebook.react.bridge.Promise;
+// import com.facebook.react.bridge.ReactApplicationContext;
+// import com.facebook.react.bridge.ReactContext;
+// import com.facebook.react.bridge.ReactContextBaseJavaModule;
+// import com.facebook.react.bridge.ReactMethod;
+// import com.facebook.react.bridge.ReadableMap;
+// import com.facebook.react.bridge.WritableArray;
+// import com.facebook.react.bridge.WritableMap;
+// import com.facebook.react.modules.core.DeviceEventManagerModule;
+// import com.sendbird.calls.AcceptParams;
+// import com.sendbird.calls.AuthenticateParams;
+// import com.sendbird.calls.CallOptions;
+// import com.sendbird.calls.DialParams;
+// import com.sendbird.calls.DirectCall;
+// import com.sendbird.calls.DirectCallUser;
+// import com.sendbird.calls.RecordingOptions;
+// import com.sendbird.calls.SendBirdCall;
+// import com.sendbird.calls.SendBirdException;
+// import com.sendbird.calls.handler.DirectCallListener;
+// import com.sendbird.calls.handler.RecordingListener;
+// import com.sendbird.calls.handler.SendBirdCallListener;
+
+// import org.jetbrains.annotations.NotNull;
+
+// import java.io.File;
+// import java.util.ArrayList;
+// import java.util.Arrays;
+// import java.util.HashMap;
+// import java.util.List;
+// import java.util.Map;
+// import java.util.Objects;
+// import java.util.UUID;
+
+// public class RNSendBirdCallsModule extends ReactContextBaseJavaModule {
+
+//   private static ReactApplicationContext mContext;
+//   private static String TAG = "RNSendBirdCalls";
+
+//   static Boolean IS_CALL_ACCEPTED = false;
+//   static Boolean IS_CALL_CONNECTED = false;
+//   private static Boolean IS_INITIAL = false;
+//   private static Boolean IS_SEND_EVENT_RINGING = false;
+//   private static ArrayList<String> JS_EVENTS = new ArrayList<String>();
+//   private static ArrayList<String> EVENTS = new ArrayList<String>(
+//       Arrays.asList(
+//           "onRinging",
+//           "onCallDidAccept",
+//           "onConnected",
+//           "onEnded",
+//           "onReconnected",
+//           "onReconnecting",
+//           "onRemoteAudioSettingsChanged",
+//           "onRemoteVideoSettingsChanged",
+//           "onRecordingSucceeded",
+//           "onRecordingFailed"
+//       )
+//   );
+
+//   static DirectCall CALL_ACTIVE = null;
+
+//   public RNSendBirdCallsModule(ReactApplicationContext reactContext) {
+//     super(reactContext);
+//     this.mContext = reactContext;
+//   }
+
+//   @Override
+//   public String getName() {
+//     return TAG;
+//   }
+
+//   private static WritableMap getParamDirectCall(@NotNull DirectCall directCall) {
+//     WritableMap params = Arguments.createMap();
+
+//     WritableMap callerMap = Arguments.createMap();
+//     WritableMap calleeMap = Arguments.createMap();
+//     WritableMap customItems = Arguments.createMap();
+
+//     if (directCall.getCustomItems().get("appointmentScheduleId") != null) {
+//       customItems.putString("appointmentScheduleId", directCall.getCustomItems().get("appointmentScheduleId"));
+//     }
+
+//     if (directCall.getCustomItems().get("eClinicId") != null) {
+//       customItems.putString("eClinicId", directCall.getCustomItems().get("eClinicId"));
+//     }
+
+//     DirectCallUser caller = directCall.getCaller();
+//     if (caller.getUserId() != null) callerMap.putString("userId", caller.getUserId());
+//     if (caller.getNickname() != null) callerMap.putString("nickname", caller.getNickname());
+//     if (caller.getProfileUrl() != null) callerMap.putString("profileUrl", caller.getProfileUrl());
+
+//     DirectCallUser callee = directCall.getCallee();
+//     if (callee.getUserId() != null) calleeMap.putString("userId", callee.getUserId());
+//     if (callee.getNickname() != null) calleeMap.putString("nickname", callee.getNickname());
+//     if (callee.getProfileUrl() != null) calleeMap.putString("profileUrl", callee.getProfileUrl());
+
+//     params.putMap("callee", calleeMap);
+//     params.putMap("caller", callerMap);
+//     params.putMap("customItems", customItems);
+
+//     String callId = directCall.getCallId();
+//     if (callId != null) params.putString("callId", callId);
+//     else params.putString("callId", "");
+
+//     float duration = directCall.getDuration();
+//     if (duration > 0) params.putDouble("duration", directCall.getDuration());
+//     else params.putDouble("duration", 0);
+
+//     Boolean isVideoCall = directCall.isVideoCall();
+//     Boolean isRemoteAudioEnabled = directCall.isRemoteAudioEnabled();
+//     Boolean isLocalAudioEnabled = directCall.isLocalAudioEnabled();
+
+//     Boolean isRemoteVideoEnabled = directCall.isRemoteVideoEnabled();
+//     Boolean isLocalVideoEnabled = directCall.isLocalVideoEnabled();
+
+//     if (isVideoCall != null) params.putBoolean("isVideoCall", isVideoCall);
+//     if (isRemoteAudioEnabled != null)
+//       params.putBoolean("isRemoteAudioEnabled", isRemoteAudioEnabled);
+//     if (isLocalAudioEnabled != null) params.putBoolean("isLocalAudioEnabled", isLocalAudioEnabled);
+//     if (isRemoteVideoEnabled != null)
+//       params.putBoolean("isRemoteVideoEnabled", isRemoteVideoEnabled);
+//     if (isLocalVideoEnabled != null) params.putBoolean("isLocalVideoEnabled", isLocalVideoEnabled);
+
+//     return params;
+//   }
+
+//   @SuppressLint("WrongConstant")
+//   public static void configureInNative(Context appContext, String appId) {
+//     Log.w(TAG, "SendBirdCall initial");
+//     if (IS_INITIAL) {
+//       Log.w(TAG, "SendBirdCall is initial ready");
+//       return;
+//     }
+
+//     if (SendBirdCall.init(appContext, appId)) {
+//       Log.d(TAG, "configureInNative: SUCCESS");
+//       SendBirdCall.removeAllListeners();
+//       SendBirdCall.removeAllRecordingListeners();
+//       String UNIQUE_HANDLER_ID = UUID.randomUUID().toString();
+//       SendBirdCall.addListener(UNIQUE_HANDLER_ID, new SendBirdCallListener() {
+//         @Override
+//         public void onRinging(@NotNull DirectCall call) {
+//           Log.i(TAG, "onRinging");
+
+//           int ongoingCallCount = SendBirdCall.getOngoingCallCount();
+//           if (ongoingCallCount >= 2) {
+//             call.end();
+//             return;
+//           }
+
+//           handleListenerSendBirdCall(call);
+//           if (JS_EVENTS.contains("onRinging")) {
+//             sendEvent(mContext, "onRinging", call);
+//             IS_SEND_EVENT_RINGING = true;
+//           }
+
+//         }
+//       });
+//       String UNIQUE_ID = UUID.randomUUID().toString();
+
+//       SendBirdCall.addRecordingListener(UNIQUE_ID, new RecordingListener() {
+//         @Override
+//         public void onRecordingSucceeded(@NotNull DirectCall directCall, @NotNull String recorderId, @NotNull RecordingOptions recordingOptions, @NotNull String outputFilePath) {
+//           if (!EVENTS.contains("onRecordingSucceeded")) return;
+//           WritableMap params = Arguments.createMap();
+//           params.putString("outputFilePath", outputFilePath);
+//           mContext
+//               .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+//               .emit("onRecordingSucceeded", params);
+//         }
+
+//         @Override
+//         public void onRecordingFailed(@NotNull DirectCall directCall, @NotNull String recorderId, @NotNull SendBirdException e) {
+//           if (!EVENTS.contains("onRecordingFailed")) return;
+//           WritableMap params = Arguments.createMap();
+//           params.putString("errorCode", String.valueOf(e.getCode()));
+//           params.putString("errorMessage", String.valueOf(e.getMessage()));
+//           mContext
+//               .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+//               .emit("onRecordingFailed", params);
+//         }
+//       });
+
+//       int ringing = appContext.getResources().getIdentifier("ringing", "raw", appContext.getPackageName());
+//       int connecting = appContext.getResources().getIdentifier("connecting", "raw", appContext.getPackageName());
+//       int connected = appContext.getResources().getIdentifier("connected", "raw", appContext.getPackageName());
+//       setUpSoundEffects(
+//           ringing,
+//           connecting,
+//           connected,
+//           connected
+//       );
+//       IS_INITIAL = true;
+//     }
+//   }
+
+//   @ReactMethod
+//   public void initSendBird(String appId, Promise promise) {
+//     IS_INITIAL = false;
+//     Context appContext = mContext.getApplicationContext();
+//     WritableMap result = Arguments.createMap();
+//     if (SendBirdCall.init(appContext, appId)) {
+//       Log.d(TAG, "configureInNative: SUCCESS");
+//       SendBirdCall.removeAllListeners();
+//       SendBirdCall.removeAllRecordingListeners();
+//       String UNIQUE_HANDLER_ID = UUID.randomUUID().toString();
+//       SendBirdCall.addListener(UNIQUE_HANDLER_ID, new SendBirdCallListener() {
+//         @Override
+//         public void onRinging(@NotNull DirectCall call) {
+//           Log.i(TAG, "onRinging");
+
+//           int ongoingCallCount = SendBirdCall.getOngoingCallCount();
+//           if (ongoingCallCount >= 2) {
+//             call.end();
+//             return;
+//           }
+
+//           handleListenerSendBirdCall(call);
+//           if (JS_EVENTS.contains("onRinging")) {
+//             sendEvent(mContext, "onRinging", call);
+//             IS_SEND_EVENT_RINGING = true;
+//           }
+
+//         }
+//       });
+//       String UNIQUE_ID = UUID.randomUUID().toString();
+
+//       SendBirdCall.addRecordingListener(UNIQUE_ID, new RecordingListener() {
+//         @Override
+//         public void onRecordingSucceeded(@NotNull DirectCall directCall, @NotNull String recorderId, @NotNull RecordingOptions recordingOptions, @NotNull String outputFilePath) {
+//           if (!EVENTS.contains("onRecordingSucceeded")) return;
+//           WritableMap params = Arguments.createMap();
+//           params.putString("outputFilePath", outputFilePath);
+//           mContext
+//               .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+//               .emit("onRecordingSucceeded", params);
+//         }
+
+//         @Override
+//         public void onRecordingFailed(@NotNull DirectCall directCall, @NotNull String recorderId, @NotNull SendBirdException e) {
+//           if (!EVENTS.contains("onRecordingFailed")) return;
+//           WritableMap params = Arguments.createMap();
+//           params.putString("errorCode", String.valueOf(e.getCode()));
+//           params.putString("errorMessage", String.valueOf(e.getMessage()));
+//           mContext
+//               .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+//               .emit("onRecordingFailed", params);
+//         }
+//       });
+
+//       int ringing = appContext.getResources().getIdentifier("ringing", "raw", appContext.getPackageName());
+//       int connecting = appContext.getResources().getIdentifier("connecting", "raw", appContext.getPackageName());
+//       int connected = appContext.getResources().getIdentifier("connected", "raw", appContext.getPackageName());
+//       setUpSoundEffects(
+//           ringing,
+//           connecting,
+//           connected,
+//           connected
+//       );
+//       IS_INITIAL = true;
+//       result.putBoolean("succeeded", true);
+//     } else {
+//       result.putBoolean("succeeded", false);
+//     }
+//     promise.resolve(result);
+//   }
+
+//   @ReactMethod
+//   public void authenticate(String userId, String accessToken, Promise promise) {
+//     try {
+//       AuthenticateParams params = new AuthenticateParams(userId).setAccessToken(accessToken);
+//       SendBirdCall.authenticate(params, (user, e) -> {
+//         WritableMap result = Arguments.createMap();
+//         if (e == null) {
+//           // The user has been authenticated successfully and is connected to Sendbird server
+//           result.putBoolean("succeeded", true);
+//           result.putString("userId", user.getUserId());
+//           result.putString("nickname", user.getNickname());
+//           Log.d(TAG, "authenticate: " + user.getNickname());
+//         } else {
+//           result.putBoolean("succeeded", false);
+//           result.putString("errorCode", String.valueOf(e.getCode()));
+//           result.putString("errorMessage", e.getMessage());
+//           Log.d(TAG, "authenticate: " + e.getMessage());
+//         }
+//         promise.resolve(result);
+//       });
+//     } catch (Exception e) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", String.valueOf(e.getMessage()));
+//       promise.resolve(result);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void deAuthenticate(Promise promise) {
+//     SendBirdCall.deauthenticate(e -> {
+//       Log.d(TAG, "deAuthen");
+//       WritableMap result = Arguments.createMap();
+//       if (e == null) {
+//         result.putBoolean("succeeded", true);
+//       } else {
+//         result.putBoolean("succeeded", false);
+//         result.putString("errorCode", String.valueOf(e.getCode()));
+//         result.putString("errorMessage", String.valueOf(e.getMessage()));
+//       }
+//       promise.resolve(result);
+//     });
+//   }
+
+//   @ReactMethod
+//   public void shareStorage(String appId) {
+//     if (appId.isEmpty()) {
+//       return;
+//     }
+//     SharedPreferences shareReference = mContext.getApplicationContext().getSharedPreferences("EDOCTOR_NATIVE", Context.MODE_PRIVATE);
+//     SharedPreferences.Editor editor = shareReference.edit();
+//     editor.putString("ANDROID_APP_ID", appId);
+//     editor.apply();
+//   }
+
+//   public static String getAppId(Context context) {
+//     SharedPreferences shareReference = context.getSharedPreferences("EDOCTOR_NATIVE", Context.MODE_PRIVATE);
+//     return shareReference.getString("ANDROID_APP_ID", "");
+//   }
+
+//   @ReactMethod
+//   public void getCall(String callId, Promise promise) {
+//     DirectCall mdirectCall = SendBirdCall.getCall(callId);
+//     if (mdirectCall != null) {
+//       WritableMap callInfo = getParamDirectCall(mdirectCall);
+//       callInfo.putBoolean("succeeded", true);
+//       promise.resolve(callInfo);
+//     } else {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", "Cuộc gọi không tồn tại");
+//       promise.resolve(result);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void registerPushToken(String token, Promise promise) {
+//     if (SendBirdCall.getCurrentUser() != null) {
+//       SendBirdCall.registerPushToken(token, false, e -> {
+//         if (e != null) {
+//           Log.i("RNSendBirdCalls", "registerPushToken => e: " + e.getMessage());
+//           WritableMap result = Arguments.createMap();
+//           result.putBoolean("succeeded", false);
+//           result.putString("errorCode", String.valueOf(e.getCode()));
+//           result.putString("errorMessage", String.valueOf(e.getMessage()));
+//           promise.resolve(result);
+//         } else {
+//           WritableMap result = Arguments.createMap();
+//           result.putBoolean("succeeded", true);
+//           promise.resolve(result);
+//         }
+//       });
+//     }
+//   }
+
+//   @ReactMethod
+//   public void unregisterPushToken(String token, Promise promise) {
+//     if (SendBirdCall.getCurrentUser() != null) {
+//       SendBirdCall.unregisterPushToken(token, e -> {
+//         WritableMap result = Arguments.createMap();
+//         if (e == null) {
+//           result.putBoolean("succeeded", true);
+//         } else {
+//           result.putBoolean("succeeded", false);
+//           result.putString("errorCode", String.valueOf(e.getCode()));
+//           result.putString("errorMessage", String.valueOf(e.getMessage()));
+//         }
+//         promise.resolve(result);
+//       });
+//     } else {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       promise.resolve(result);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void startRecording(String fileName, boolean isRemote, Promise promise) {
+//     try {
+//       File myDir = new File(mContext.getApplicationContext().getFilesDir().getAbsolutePath() + "/records");
+//       if (!myDir.exists()) {
+//         myDir.mkdirs();
+//       }
+//       RecordingOptions options;
+//       if (isRemote) {
+//         options = new RecordingOptions(RecordingOptions.RecordingType.LOCAL_AUDIO_REMOTE_AUDIO_AND_VIDEO, myDir.getAbsolutePath(), fileName);
+//       } else {
+//         options = new RecordingOptions(RecordingOptions.RecordingType.LOCAL_AUDIO_AND_VIDEO_REMOTE_AUDIO, myDir.getAbsolutePath(), fileName);
+//       }
+//       CALL_ACTIVE.startRecording(options, (recordingId, e) -> {
+//         WritableMap result = Arguments.createMap();
+//         if (e == null) {
+//           result.putBoolean("succeeded", true);
+//           result.putString("recordingId", recordingId);
+//           Log.d(TAG, "recordingId: " + recordingId);
+//         } else {
+//           result.putBoolean("succeeded", false);
+//           result.putString("errorCode", String.valueOf(e.getCode()));
+//           result.putString("errorMessage", String.valueOf(e.getMessage()));
+//           Log.d(TAG, "errorMessage: " + String.valueOf(e.getMessage()));
+
+//         }
+
+//         promise.resolve(result);
+//       });
+//     } catch (Exception e) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", e.getMessage());
+//       promise.resolve(result);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void stopRecording(String recordingId, Promise promise) {
+//     Log.d(TAG, "stopRecording: " + recordingId);
+//     if (CALL_ACTIVE == null) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", "Cuộc gọi không tồn tại");
+//       promise.resolve(result);
+//     }
+//     boolean succeeded = CALL_ACTIVE.stopRecording(recordingId);
+//     WritableMap result = Arguments.createMap();
+//     result.putBoolean("succeeded", succeeded);
+//     promise.resolve(result);
+//   }
+
+//   @ReactMethod
+//   public void dial(String calleeId, boolean isVideoCall, boolean isVideoEnable, boolean isAudioEnable, String appointmentScheduleId, String eClinicId, Promise promise) {
+//     Log.d(TAG, "dial");
+
+//     int ongoingCallCount = SendBirdCall.getOngoingCallCount();
+//     if (ongoingCallCount > 0) {
+//       return;
+//     }
+
+//     CallOptions callOptions = new CallOptions().setVideoEnabled(isVideoEnable).setAudioEnabled(isAudioEnable);
+//     Map<String, String> customItems = new HashMap<>();
+//     customItems.put("appointmentScheduleId", appointmentScheduleId);
+//     customItems.put("eClinicId", eClinicId);
+
+//     DialParams dialParams = new DialParams(calleeId);
+//     dialParams.setVideoCall(isVideoCall);
+//     dialParams.setCallOptions(callOptions);
+//     dialParams.setCustomItems(customItems);
+
+//     DirectCall mDirectCall = SendBirdCall.dial(dialParams, (call, e) -> {
+//       if (e != null) {
+//         Log.d(TAG, "dial: " + e.getMessage());
+//         WritableMap result = Arguments.createMap();
+//         result.putBoolean("succeeded", false);
+//         result.putString("errorCode", String.valueOf(e.getCode()));
+//         result.putString("errorMessage", String.valueOf(e.getMessage()));
+//         promise.resolve(result);
+//         return;
+//       }
+//       WritableMap params = Arguments.createMap();
+//       params.putBoolean("succeeded", true);
+//       params.putString("callId", call.getCallId());
+//       params.putString("caller", call.getCaller().getUserId());
+//       params.putString("callee", call.getCallee().getUserId());
+//       promise.resolve(params);
+//     });
+
+//     if (mDirectCall != null) {
+//       handleListenerSendBirdCall(mDirectCall);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void muteMicrophone(Promise promise) {
+//     Log.i(TAG, "muteMicrophone");
+//     if (CALL_ACTIVE == null) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", "Cuộc gọi không tồn tại");
+//       promise.resolve(result);
+//     }
+//     ;
+//     boolean succeeded = CALL_ACTIVE.muteMicrophone();
+//     WritableMap result = Arguments.createMap();
+//     result.putBoolean("succeeded", succeeded);
+//     promise.resolve(result);
+//   }
+
+//   @ReactMethod
+//   public void unmuteMicrophone(Promise promise) {
+//     Log.i(TAG, "unmuteMicrophone");
+//     if (CALL_ACTIVE == null) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", "Cuộc gọi không tồn tại");
+//       promise.resolve(result);
+//     }
+//     ;
+//     boolean succeeded = CALL_ACTIVE.unmuteMicrophone();
+//     WritableMap result = Arguments.createMap();
+//     result.putBoolean("succeeded", succeeded);
+//     promise.resolve(result);
+//   }
+
+//   @ReactMethod
+//   public void startVideo(Promise promise) {
+//     Log.i(TAG, "startVideo");
+//     if (CALL_ACTIVE == null) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", "Cuộc gọi không tồn tại");
+//       promise.resolve(result);
+//     }
+//     ;
+//     try {
+//       CALL_ACTIVE.startVideo();
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", true);
+//       promise.resolve(result);
+//     } catch (Exception e) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", e.getMessage());
+//       promise.resolve(result);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void stopVideo(Promise promise) {
+//     Log.i(TAG, "stopVideo");
+//     if (CALL_ACTIVE == null) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", "Cuộc gọi không tồn tại");
+//       promise.resolve(result);
+//     }
+//     ;
+//     try {
+//       CALL_ACTIVE.stopVideo();
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", true);
+//       promise.resolve(result);
+//     } catch (Exception e) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", e.getMessage());
+//       promise.resolve(result);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void switchCamera(Promise promise) {
+//     Log.i(TAG, "switchCamera");
+//     if (CALL_ACTIVE == null) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", "Cuộc gọi không tồn tại");
+//       promise.resolve(result);
+//     }
+//     ;
+//     CALL_ACTIVE.switchCamera(e -> {
+//       WritableMap result = Arguments.createMap();
+//       if (e != null) {
+//         result.putBoolean("succeeded", false);
+//         result.putString("errorCode", String.valueOf(e.getCode()));
+//         result.putString("errorMessage", String.valueOf(e.getMessage()));
+//       } else {
+//         result.putBoolean("succeeded", true);
+//       }
+//       promise.resolve(result);
+//     });
+//   }
+
+//   @ReactMethod
+//   public void endCall(Promise promise) {
+//     Log.i(TAG, "endCall");
+//     if (CALL_ACTIVE != null) {
+//       IS_CALL_ACCEPTED = false;
+//       IS_CALL_CONNECTED = false;
+//       WritableMap params = Arguments.createMap();
+//       params.putString("callId", CALL_ACTIVE.getCallId());
+//       params.putString("caller", CALL_ACTIVE.getCaller().getUserId());
+//       params.putString("callee", CALL_ACTIVE.getCallee().getUserId());
+//       params.putString("duration", String.valueOf(CALL_ACTIVE.getDuration()));
+//       try {
+//         CALL_ACTIVE.end();
+//         promise.resolve(params);
+//       } catch (Exception e) {
+//         WritableMap result = Arguments.createMap();
+//         result.putBoolean("succeeded", false);
+//         result.putString("errorMessage", e.getMessage());
+//         promise.resolve(result);
+//       }
+//     } else {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", "Cuộc gọi không tồn tại");
+//       promise.resolve(result);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void acceptCall(String callId, boolean isVideoEnable, boolean isAudioEnable, Promise promise) {
+//     Log.i(TAG, "acceptCall");
+//     try {
+//       DirectCall mDirectCall = SendBirdCall.getCall(callId);
+//       if (mDirectCall != null) {
+//         handleListenerSendBirdCall(mDirectCall);
+//         CallOptions callOptions = new CallOptions().setVideoEnabled(isVideoEnable).setAudioEnabled(isAudioEnable);
+//         mDirectCall.accept(new AcceptParams().setCallOptions(callOptions));
+//         IS_CALL_ACCEPTED = true;
+//         WritableMap result = Arguments.createMap();
+//         result.putBoolean("succeeded", true);
+//         promise.resolve(result);
+//       }
+//     } catch (Exception e) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", "Cuộc gọi không tồn tại");
+//       promise.resolve(result);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void endIncomingCallNeedAuthentication(String callId, Promise promise) {
+//     Log.i(TAG, "endIncomingCallNeedAuthentication");
+//     try {
+//       DirectCall mDirectCall = SendBirdCall.getCall(callId);
+//       DirectCallUser callee = mDirectCall.getCallee();
+//       AuthenticateParams params = new AuthenticateParams(callee.getUserId());
+//       SendBirdCall.authenticate(params, (user, e) -> {
+//         if (e == null) {
+//           if (mDirectCall != null) {
+//             mDirectCall.end();
+//             IS_CALL_ACCEPTED = false;
+//             IS_CALL_CONNECTED = false;
+//             WritableMap result = Arguments.createMap();
+//             result.putBoolean("succeeded", true);
+//             promise.resolve(result);
+//           }
+//         } else {
+//           WritableMap result = Arguments.createMap();
+//           result.putBoolean("succeeded", false);
+//           result.putString("errorCode", String.valueOf(e.getCode()));
+//           result.putString("errorMessage", String.valueOf(e.getMessage()));
+//           promise.resolve(result);
+//         }
+//       });
+//     } catch (Exception e) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", e.getMessage());
+//       promise.resolve(result);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void acceptIncomingCallNeedAuthentication(String callId, boolean isVideoEnable, boolean isAudioEnable, Promise promise) {
+//     Log.i(TAG, "acceptIncomingCallNeedAuthentication");
+//     try {
+//       DirectCall mDirectCall = SendBirdCall.getCall(callId);
+//       DirectCallUser callee = mDirectCall.getCallee();
+//       AuthenticateParams params = new AuthenticateParams(callee.getUserId());
+//       SendBirdCall.authenticate(params, (user, e) -> {
+//         if (e == null) {
+//           if (mDirectCall != null) {
+//             handleListenerSendBirdCall(mDirectCall);
+//             CallOptions callOptions = new CallOptions().setVideoEnabled(isVideoEnable).setAudioEnabled(isAudioEnable);
+//             mDirectCall.accept(new AcceptParams().setCallOptions(callOptions));
+//             IS_CALL_ACCEPTED = true;
+//             WritableMap result = Arguments.createMap();
+//             result.putBoolean("succeeded", true);
+//             promise.resolve(result);
+//           }
+//         } else {
+//           WritableMap result = Arguments.createMap();
+//           result.putBoolean("succeeded", false);
+//           result.putString("errorCode", String.valueOf(e.getCode()));
+//           result.putString("errorMessage", String.valueOf(e.getMessage()));
+//           promise.resolve(result);
+//         }
+//       });
+//     } catch (Exception e) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", e.getMessage());
+//       promise.resolve(result);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void getOngoingCalls(Promise promise) {
+//     List<DirectCall> directCall = SendBirdCall.getOngoingCalls();
+//     WritableArray resultData = Arguments.createArray();
+//     if (directCall != null && directCall.isEmpty() == false) {
+//       for (int i = 0; i < directCall.size(); i++) {
+//         WritableMap item = getParamDirectCall(directCall.get(i));
+//         if (item != null) {
+//           resultData.pushMap(item);
+//         }
+//       }
+//       promise.resolve(resultData);
+//     } else {
+//       promise.resolve(null);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void getCallInfo(Promise promise) {
+//     if (CALL_ACTIVE == null) {
+//       promise.resolve(null);
+//     } else {
+//       DirectCall mdirectCall = SendBirdCall.getCall(CALL_ACTIVE.getCallId());
+//       if (mdirectCall == null) promise.resolve(null);
+//       else {
+//         Log.d(TAG, "getCallInfo: " + mdirectCall);
+//         DirectCallUser callee = mdirectCall.getCallee();
+//         DirectCallUser caller = mdirectCall.getCaller();
+//       }
+//     }
+//   }
+
+//   @ReactMethod
+//   public void wakeAppIncomingCall(ReadableMap params) {
+//     Log.d(TAG, "wakeAppIncomingCall: ");
+//     Bundle bundle = Arguments.toBundle(params);
+//     Intent intent = new Intent(mContext.getApplicationContext(), VoIPService.class);
+//     intent.putExtras(bundle);
+//     if (Build.VERSION.SDK_INT > Build.VERSION_CODES.O) {
+//       mContext.getApplicationContext().startForegroundService(intent);
+//     } else {
+//       mContext.getApplicationContext().startService(intent);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void navigateMainApp(ReadableMap params) {
+//     Log.d(TAG, "navigateMainApp: ");
+//     Bundle bundle = Arguments.toBundle(params);
+//     SharedUtils.navigateMainApp(mContext.getApplicationContext(), bundle);
+//   }
+
+//   @ReactMethod
+//   public void finishLockedScreenUI() {
+//     Objects.requireNonNull(mContext.getCurrentActivity()).finish();
+//   }
+
+//   @ReactMethod
+//   public void getDeviceLocked(Promise promise) {
+//     try {
+//       boolean isLocked = SharedUtils.getDeviceLocked(mContext.getApplicationContext());
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", true);
+//       result.putBoolean("isLocked", isLocked);
+//       promise.resolve(result);
+//     } catch (RuntimeException e) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", e.getMessage());
+//       promise.resolve(result);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void cancelComingCallNotification() {
+// //        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return;
+//     SharedUtils.cancelComingCallNotification();
+//   }
+
+//   @ReactMethod
+//   public void isAppInForeground(Promise promise) {
+//     try {
+//       boolean isInForeground = SharedUtils.isAppInForeground(mContext.getApplicationContext());
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", true);
+//       result.putBoolean("isInForeground", isInForeground);
+//       promise.resolve(result);
+//     } catch (RuntimeException e) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", e.getMessage());
+//       promise.resolve(result);
+//     }
+//   }
+
+//   @ReactMethod
+//   public void setNativeEvent(String event) {
+//     JS_EVENTS.add(event);
+//     if (event.contains("onRinging")
+//         && IS_SEND_EVENT_RINGING == false
+//         && IS_CALL_ACCEPTED == false
+//         && IS_CALL_CONNECTED == false
+//         && CALL_ACTIVE != null) {
+//       sendEvent(mContext, "onRinging", CALL_ACTIVE);
+//       IS_SEND_EVENT_RINGING = true;
+//     }
+// //        if(event.contains("onCallDidAccept")
+// //                && IS_CALL_ACCEPTED == true
+// //                && IS_CALL_CONNECTED == false
+// //                && CALL_ACTIVE != null ){
+// //                sendEvent(mContext, "onConnected", CALL_ACTIVE);
+// //                IS_CALL_CONNECTED = true;
+// //        }
+//   }
+
+//   @ReactMethod
+//   public void removeNativeEvent(String event) {
+//     JS_EVENTS.remove(event);
+//   }
+
+//   @ReactMethod
+//   public void removeAllEvents() {
+//     SendBirdCall.removeAllListeners();
+//     SendBirdCall.removeAllRecordingListeners();
+//   }
+
+//   @ReactMethod
+//   public void endAllCalls(Promise promise) {
+//     try {
+//       List<DirectCall> directCall = SendBirdCall.getOngoingCalls();
+//       if (!directCall.isEmpty()) {
+//         for (int i = 0; i < directCall.size(); i++) {
+//           directCall.get(i).end();
+//         }
+//       }
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", true);
+//       promise.resolve(result);
+//     } catch (RuntimeException e) {
+//       WritableMap result = Arguments.createMap();
+//       result.putBoolean("succeeded", false);
+//       result.putString("errorMessage", e.getMessage());
+//       promise.resolve(result);
+//     }
+//   }
+
+//   public static void endCalls() {
+//     try {
+//       List<DirectCall> directCall = SendBirdCall.getOngoingCalls();
+//       if (!directCall.isEmpty()) {
+//         for (int i = 0; i < directCall.size(); i++) {
+//           directCall.get(i).end();
+//         }
+//       }
+//     } catch (RuntimeException e) {
+//       Log.d(TAG, "endCalls: " + e);
+//     }
+//   }
+
+//   private boolean contains(ArrayList array, String value) {
+//     for (int i = 0; i < array.size(); i++) {
+//       if (array.get(i).equals(value)) {
+//         return true;
+//       }
+//     }
+//     return false;
+//   }
+
+
+//   private static void handleListenerSendBirdCall(DirectCall mDirectCall) {
+//     if (mDirectCall == null) return;
+//     CALL_ACTIVE = mDirectCall;
+//     mDirectCall.setListener(new DirectCallListener() {
+//       @Override
+//       public void onEstablished(@NotNull DirectCall directCall) {
+//         //Remote user accepted the call.
+//         Log.i(TAG, "onEstablished");
+//         sendEvent(mContext, "onCallDidAccept", directCall);
+//       }
+
+//       @Override
+//       public void onConnected(@NotNull DirectCall directCall) {
+//         Log.i(TAG, "onConnected");
+//         WritableMap params = Arguments.createMap();
+//         sendEvent(mContext, "onConnected", directCall);
+//       }
+
+//       @Override
+//       public void onEnded(@NotNull DirectCall directCall) {
+//         Log.i(TAG, "onEnded");
+//         sendEvent(mContext, "onEnded", directCall);
+//         IS_CALL_ACCEPTED = false;
+//         IS_CALL_CONNECTED = false;
+//         CALL_ACTIVE = null;
+//       }
+
+//       @Override
+//       public void onReconnected(@NonNull DirectCall directCall) {
+//         Log.i(TAG, "onReconnected");
+//         sendEvent(mContext, "onReconnected", directCall);
+//       }
+
+//       @Override
+//       public void onReconnecting(@NonNull DirectCall directCall) {
+//         Log.i(TAG, "onReconnecting");
+//         sendEvent(mContext, "onReconnecting", directCall);
+//       }
+
+//       @Override
+//       public void onRemoteAudioSettingsChanged(DirectCall directCall) {
+//         Log.i(TAG, "onRemoteAudioSettingsChanged");
+//         sendEvent(mContext, "onRemoteAudioSettingsChanged", directCall);
+//       }
+
+//       @Override
+//       public void onRemoteVideoSettingsChanged(DirectCall directCall) {
+//         sendEvent(mContext, "onRemoteVideoSettingsChanged", directCall);
+//       }
+
+//     });
+//   }
+
+//   public static void sendEvent(ReactContext reactContext, String eventName, DirectCall directCall) {
+//     if (!EVENTS.contains(eventName)) return;
+//     WritableMap params = getParamDirectCall(directCall);
+//     reactContext
+//         .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+//         .emit(eventName, params);
+//   }
+
+//   public static void onMessageReceived(Context context, Map<String, String> data) {
+//     int ringing = context.getResources().getIdentifier("ringing", "raw", context.getPackageName());
+//     int connecting = context.getResources().getIdentifier("connecting", "raw", context.getPackageName());
+//     int connected = context.getResources().getIdentifier("connected", "raw", context.getPackageName());
+//     setUpSoundEffects(
+//         ringing,
+//         connecting,
+//         connected,
+//         connected
+//     );
+//     SendBirdCall.handleFirebaseMessageData(data);
+//   }
+
+//   public static void onNewToken(String token) {
+//     if (SendBirdCall.getCurrentUser() != null) {
+//       SendBirdCall.registerPushToken(token, false, e -> {
+//         if (e != null) {
+//           Log.i("RNSendBirdCalls", "[FirebaseMessagingService] onNewToken() => e: " + e.getMessage());
+//         }
+//       });
+//     }
+//   }
+
+//   static public void setUpSoundEffects(
+//       @Nullable Integer ringingId,
+//       @Nullable Integer dialing,
+//       @Nullable Integer connectingId,
+//       @Nullable Integer connectedId
+//   ) {
+//     if (ringingId != null)
+//       SendBirdCall.Options.addDirectCallSound(SendBirdCall.SoundType.RINGING, ringingId);
+//     if (dialing != null)
+//       SendBirdCall.Options.addDirectCallSound(SendBirdCall.SoundType.DIALING, dialing);
+//     if (connectingId != null)
+//       SendBirdCall.Options.addDirectCallSound(SendBirdCall.SoundType.RECONNECTING, connectingId);
+//     if (connectedId != null)
+//       SendBirdCall.Options.addDirectCallSound(SendBirdCall.SoundType.RECONNECTED, connectedId);
+//     SendBirdCall.Options.setDirectCallDialingSoundOnWhenSilentOrVibrateMode(true);
+//   }
+// }
+
+
+package com.rnsendbirdcalls;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.os.Build;
+import android.os.Bundle;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.sendbird.calls.AcceptParams;
+import com.sendbird.calls.AuthenticateParams;
+import com.sendbird.calls.CallOptions;
+import com.sendbird.calls.DialParams;
+import com.sendbird.calls.DirectCall;
+import com.sendbird.calls.DirectCallUser;
+import com.sendbird.calls.RecordingOptions;
+import com.sendbird.calls.SendBirdCall;
+import com.sendbird.calls.SendBirdException;
+import com.sendbird.calls.handler.DirectCallListener;
+import com.sendbird.calls.handler.RecordingListener;
+import com.sendbird.calls.handler.SendBirdCallListener;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+
+public class RNSendBirdCallsModule extends ReactContextBaseJavaModule {
+
+  private static ReactApplicationContext mContext;
+  private static final String TAG = "RNSendBirdCalls";
+
+  private static Boolean IS_CALL_ACCEPTED = false;
+  private static Boolean IS_CALL_CONNECTED = false;
+  private static Boolean IS_INITIAL = false;
+  private static Boolean IS_SEND_EVENT_RINGING = false;
+  private static final ArrayList<String> JS_EVENTS = new ArrayList<>();
+  private static final ArrayList<String> EVENTS = new ArrayList<>(
+      Arrays.asList(
+          "onRinging",
+          "onCallDidAccept",
+          "onConnected",
+          "onEnded",
+          "onReconnected",
+          "onReconnecting",
+          "onRemoteAudioSettingsChanged",
+          "onRemoteVideoSettingsChanged",
+          "onRecordingSucceeded",
+          "onRecordingFailed"
+      )
+  );
+
+  private static DirectCall CALL_ACTIVE = null;
+
+  public RNSendBirdCallsModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    mContext = reactContext;
+  }
+
+  @NonNull
+  @Override
+  public String getName() {
+    return TAG;
+  }
+
+  // MARK: - Helper Methods
+  private static WritableMap getParamDirectCall(@NotNull DirectCall directCall) {
+    WritableMap params = Arguments.createMap();
+
+    WritableMap callerMap = Arguments.createMap();
+    WritableMap calleeMap = Arguments.createMap();
+    WritableMap customItems = Arguments.createMap();
+
+    // Custom items
+    Map<String, String> customItemsData = directCall.getCustomItems();
+    if (customItemsData != null) {
+      if (customItemsData.get("appointmentScheduleId") != null) {
+        customItems.putString("appointmentScheduleId", customItemsData.get("appointmentScheduleId"));
+      }
+      if (customItemsData.get("eClinicId") != null) {
+        customItems.putString("eClinicId", customItemsData.get("eClinicId"));
+      }
+    }
+
+    // Caller info
+    DirectCallUser caller = directCall.getCaller();
+    if (caller != null) {
+      callerMap.putString("userId", caller.getUserId() != null ? caller.getUserId() : "");
+      callerMap.putString("nickname", caller.getNickname() != null ? caller.getNickname() : "");
+      callerMap.putString("profileUrl", caller.getProfileUrl() != null ? caller.getProfileUrl() : "");
+    }
+
+    // Callee info
+    DirectCallUser callee = directCall.getCallee();
+    if (callee != null) {
+      calleeMap.putString("userId", callee.getUserId() != null ? callee.getUserId() : "");
+      calleeMap.putString("nickname", callee.getNickname() != null ? callee.getNickname() : "");
+      calleeMap.putString("profileUrl", callee.getProfileUrl() != null ? callee.getProfileUrl() : "");
+    }
+
+    params.putMap("callee", calleeMap);
+    params.putMap("caller", callerMap);
+    params.putMap("customItems", customItems);
+
+    // Call info
+    params.putString("callId", directCall.getCallId() != null ? directCall.getCallId() : "");
+    params.putDouble("duration", directCall.getDuration());
+    params.putBoolean("isVideoCall", directCall.isVideoCall());
+    params.putBoolean("isRemoteAudioEnabled", directCall.isRemoteAudioEnabled());
+    params.putBoolean("isLocalAudioEnabled", directCall.isLocalAudioEnabled());
+    params.putBoolean("isRemoteVideoEnabled", directCall.isRemoteVideoEnabled());
+    params.putBoolean("isLocalVideoEnabled", directCall.isLocalVideoEnabled());
+
+    return params;
+  }
+
+  @SuppressLint("WrongConstant")
+  public static void configureInNative(Context appContext, String appId) {
+    Log.w(TAG, "SendBirdCall initial");
+    if (IS_INITIAL) {
+      Log.w(TAG, "SendBirdCall is initial ready");
+      return;
+    }
+
+    if (SendBirdCall.init(appContext, appId)) {
+      Log.d(TAG, "configureInNative: SUCCESS");
+      setupSendBirdListeners();
+      setupSoundEffects(appContext);
+      IS_INITIAL = true;
+    }
+  }
+
+  private static void setupSendBirdListeners() {
+    SendBirdCall.removeAllListeners();
+    SendBirdCall.removeAllRecordingListeners();
+    
+    String UNIQUE_HANDLER_ID = UUID.randomUUID().toString();
+    SendBirdCall.addListener(UNIQUE_HANDLER_ID, new SendBirdCallListener() {
+      @Override
+      public void onRinging(@NotNull DirectCall call) {
+        Log.i(TAG, "onRinging");
+
+        int ongoingCallCount = SendBirdCall.getOngoingCallCount();
+        if (ongoingCallCount >= 2) {
+          call.end();
+          return;
+        }
+
+        handleListenerSendBirdCall(call);
+        if (JS_EVENTS.contains("onRinging")) {
+          sendEvent(mContext, "onRinging", call);
+          IS_SEND_EVENT_RINGING = true;
+        }
+      }
+    });
+
+    String UNIQUE_ID = UUID.randomUUID().toString();
+    SendBirdCall.addRecordingListener(UNIQUE_ID, new RecordingListener() {
+      @Override
+      public void onRecordingSucceeded(@NotNull DirectCall directCall, @NotNull String recorderId, @NotNull RecordingOptions recordingOptions, @NotNull String outputFilePath) {
+        if (!JS_EVENTS.contains("onRecordingSucceeded")) return;
+        WritableMap params = Arguments.createMap();
+        params.putString("outputFilePath", outputFilePath);
+        if (mContext != null) {
+          mContext
+              .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+              .emit("onRecordingSucceeded", params);
+        }
+      }
+
+      @Override
+      public void onRecordingFailed(@NotNull DirectCall directCall, @NotNull String recorderId, @NotNull SendBirdException e) {
+        if (!JS_EVENTS.contains("onRecordingFailed")) return;
+        WritableMap params = Arguments.createMap();
+        params.putString("errorCode", String.valueOf(e.getCode()));
+        params.putString("errorMessage", String.valueOf(e.getMessage()));
+        if (mContext != null) {
+          mContext
+              .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+              .emit("onRecordingFailed", params);
+        }
+      }
+    });
+  }
+
+  private static void setupSoundEffects(Context context) {
+    int ringing = context.getResources().getIdentifier("ringing", "raw", context.getPackageName());
+    int connecting = context.getResources().getIdentifier("connecting", "raw", context.getPackageName());
+    int connected = context.getResources().getIdentifier("connected", "raw", context.getPackageName());
+    setUpSoundEffects(ringing, connecting, connected, connected);
+  }
+
+  // MARK: - React Methods
+  @ReactMethod
+  public void initSendBird(String appId, Promise promise) {
+    try {
+      IS_INITIAL = false;
+      Context appContext = mContext.getApplicationContext();
+      WritableMap result = Arguments.createMap();
+      
+      if (SendBirdCall.init(appContext, appId)) {
+        Log.d(TAG, "initSendBird: SUCCESS");
+        setupSendBirdListeners();
+        setupSoundEffects(appContext);
+        IS_INITIAL = true;
+        result.putBoolean("succeeded", true);
+      } else {
+        result.putBoolean("succeeded", false);
+      }
+      promise.resolve(result);
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void authenticate(String userId, String accessToken, Promise promise) {
+    try {
+      AuthenticateParams params = new AuthenticateParams(userId).setAccessToken(accessToken);
+      SendBirdCall.authenticate(params, (user, e) -> {
+        WritableMap result = Arguments.createMap();
+        if (e == null) {
+          result.putBoolean("succeeded", true);
+          result.putString("userId", user.getUserId());
+          result.putString("nickname", user.getNickname() != null ? user.getNickname() : "");
+          Log.d(TAG, "authenticate: " + user.getNickname());
+        } else {
+          result.putBoolean("succeeded", false);
+          result.putString("errorCode", String.valueOf(e.getCode()));
+          result.putString("errorMessage", e.getMessage());
+          Log.d(TAG, "authenticate error: " + e.getMessage());
+        }
+        promise.resolve(result);
+      });
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void deAuthenticate(Promise promise) {
+    SendBirdCall.deauthenticate(e -> {
+      Log.d(TAG, "deAuthenticate");
+      WritableMap result = Arguments.createMap();
+      if (e == null) {
+        result.putBoolean("succeeded", true);
+      } else {
+        result.putBoolean("succeeded", false);
+        result.putString("errorCode", String.valueOf(e.getCode()));
+        result.putString("errorMessage", e.getMessage());
+      }
+      promise.resolve(result);
+    });
+  }
+
+  @ReactMethod
+  public void shareStorage(String appId) {
+    if (appId == null || appId.isEmpty()) {
+      return;
+    }
+    SharedPreferences shareReference = mContext.getApplicationContext()
+        .getSharedPreferences("EDOCTOR_NATIVE", Context.MODE_PRIVATE);
+    SharedPreferences.Editor editor = shareReference.edit();
+    editor.putString("ANDROID_APP_ID", appId);
+    editor.apply();
+  }
+
+  @ReactMethod
+  public void dial(String calleeId, boolean isVideoCall, boolean isVideoEnable, boolean isAudioEnable, 
+                   String appointmentScheduleId, String eClinicId, Promise promise) {
+    Log.d(TAG, "dial");
+
+    try {
+      int ongoingCallCount = SendBirdCall.getOngoingCallCount();
+      if (ongoingCallCount > 0) {
+        WritableMap result = Arguments.createMap();
+        result.putBoolean("succeeded", false);
+        result.putString("errorMessage", "Đã có cuộc gọi đang diễn ra");
+        promise.resolve(result);
+        return;
+      }
+
+      CallOptions callOptions = new CallOptions()
+          .setVideoEnabled(isVideoEnable)
+          .setAudioEnabled(isAudioEnable);
+      
+      Map<String, String> customItems = new HashMap<>();
+      customItems.put("appointmentScheduleId", appointmentScheduleId);
+      customItems.put("eClinicId", eClinicId);
+
+      DialParams dialParams = new DialParams(calleeId)
+          .setVideoCall(isVideoCall)
+          .setCallOptions(callOptions)
+          .setCustomItems(customItems);
+
+      DirectCall mDirectCall = SendBirdCall.dial(dialParams, (call, e) -> {
+        WritableMap result = Arguments.createMap();
+        if (e != null) {
+          Log.d(TAG, "dial error: " + e.getMessage());
+          result.putBoolean("succeeded", false);
+          result.putString("errorCode", String.valueOf(e.getCode()));
+          result.putString("errorMessage", e.getMessage());
+        } else {
+          result.putBoolean("succeeded", true);
+          result.putString("callId", call.getCallId());
+          result.putString("caller", call.getCaller().getUserId());
+          result.putString("callee", call.getCallee().getUserId());
+        }
+        promise.resolve(result);
+      });
+
+      if (mDirectCall != null) {
+        handleListenerSendBirdCall(mDirectCall);
+      }
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void acceptCall(String callId, boolean isVideoEnable, boolean isAudioEnable, Promise promise) {
+    Log.i(TAG, "acceptCall");
+    try {
+      DirectCall mDirectCall = SendBirdCall.getCall(callId);
+      if (mDirectCall != null) {
+        handleListenerSendBirdCall(mDirectCall);
+        CallOptions callOptions = new CallOptions()
+            .setVideoEnabled(isVideoEnable)
+            .setAudioEnabled(isAudioEnable);
+        mDirectCall.accept(new AcceptParams().setCallOptions(callOptions));
+        IS_CALL_ACCEPTED = true;
+        
+        WritableMap result = Arguments.createMap();
+        result.putBoolean("succeeded", true);
+        promise.resolve(result);
+      } else {
+        WritableMap result = Arguments.createMap();
+        result.putBoolean("succeeded", false);
+        result.putString("errorMessage", "Cuộc gọi không tồn tại");
+        promise.resolve(result);
+      }
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void endCall(Promise promise) {
+    Log.i(TAG, "endCall");
+    if (CALL_ACTIVE != null) {
+      try {
+        WritableMap params = getParamDirectCall(CALL_ACTIVE);
+        params.putBoolean("succeeded", true);
+        
+        IS_CALL_ACCEPTED = false;
+        IS_CALL_CONNECTED = false;
+        CALL_ACTIVE.end();
+        
+        promise.resolve(params);
+      } catch (Exception e) {
+        WritableMap result = Arguments.createMap();
+        result.putBoolean("succeeded", false);
+        result.putString("errorMessage", e.getMessage());
+        promise.resolve(result);
+      }
+    } else {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", "Cuộc gọi không tồn tại");
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void endAllCalls(Promise promise) {
+    try {
+      List<DirectCall> directCalls = SendBirdCall.getOngoingCalls();
+      if (directCalls != null && !directCalls.isEmpty()) {
+        for (DirectCall call : directCalls) {
+          call.end();
+        }
+      }
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", true);
+      promise.resolve(result);
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void getOngoingCalls(Promise promise) {
+    try {
+      List<DirectCall> directCalls = SendBirdCall.getOngoingCalls();
+      WritableArray resultData = Arguments.createArray();
+      
+      if (directCalls != null && !directCalls.isEmpty()) {
+        for (DirectCall call : directCalls) {
+          WritableMap item = getParamDirectCall(call);
+          if (item != null) {
+            resultData.pushMap(item);
+          }
+        }
+      }
+      promise.resolve(resultData);
+    } catch (Exception e) {
+      promise.resolve(Arguments.createArray()); // Return empty array on error
+    }
+  }
+
+  // MARK: - Audio/Video Controls
+  @ReactMethod
+  public void muteMicrophone(Promise promise) {
+    Log.i(TAG, "muteMicrophone");
+    if (CALL_ACTIVE == null) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", "Cuộc gọi không tồn tại");
+      promise.resolve(result);
+      return;
+    }
+    
+    try {
+      boolean succeeded = CALL_ACTIVE.muteMicrophone();
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", succeeded);
+      promise.resolve(result);
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void unmuteMicrophone(Promise promise) {
+    Log.i(TAG, "unmuteMicrophone");
+    if (CALL_ACTIVE == null) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", "Cuộc gọi không tồn tại");
+      promise.resolve(result);
+      return;
+    }
+    
+    try {
+      boolean succeeded = CALL_ACTIVE.unmuteMicrophone();
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", succeeded);
+      promise.resolve(result);
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void startVideo(Promise promise) {
+    Log.i(TAG, "startVideo");
+    if (CALL_ACTIVE == null) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", "Cuộc gọi không tồn tại");
+      promise.resolve(result);
+      return;
+    }
+    
+    try {
+      CALL_ACTIVE.startVideo();
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", true);
+      promise.resolve(result);
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void stopVideo(Promise promise) {
+    Log.i(TAG, "stopVideo");
+    if (CALL_ACTIVE == null) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", "Cuộc gọi không tồn tại");
+      promise.resolve(result);
+      return;
+    }
+    
+    try {
+      CALL_ACTIVE.stopVideo();
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", true);
+      promise.resolve(result);
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void switchCamera(Promise promise) {
+    Log.i(TAG, "switchCamera");
+    if (CALL_ACTIVE == null) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", "Cuộc gọi không tồn tại");
+      promise.resolve(result);
+      return;
+    }
+    
+    CALL_ACTIVE.switchCamera(e -> {
+      WritableMap result = Arguments.createMap();
+      if (e != null) {
+        result.putBoolean("succeeded", false);
+        result.putString("errorCode", String.valueOf(e.getCode()));
+        result.putString("errorMessage", e.getMessage());
+      } else {
+        result.putBoolean("succeeded", true);
+      }
+      promise.resolve(result);
+    });
+  }
+
+  // MARK: - Recording
+  @ReactMethod
+  public void startRecording(String fileName, boolean isRemote, Promise promise) {
+    Log.d(TAG, "startRecording");
+    if (CALL_ACTIVE == null) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", "Cuộc gọi không tồn tại");
+      promise.resolve(result);
+      return;
+    }
+
+    try {
+      File myDir = new File(mContext.getApplicationContext().getFilesDir().getAbsolutePath() + "/records");
+      if (!myDir.exists()) {
+        myDir.mkdirs();
+      }
+      
+      RecordingOptions options = isRemote 
+          ? new RecordingOptions(RecordingOptions.RecordingType.LOCAL_AUDIO_REMOTE_AUDIO_AND_VIDEO, myDir.getAbsolutePath(), fileName)
+          : new RecordingOptions(RecordingOptions.RecordingType.LOCAL_AUDIO_AND_VIDEO_REMOTE_AUDIO, myDir.getAbsolutePath(), fileName);
+
+      CALL_ACTIVE.startRecording(options, (recordingId, e) -> {
+        WritableMap result = Arguments.createMap();
+        if (e == null) {
+          result.putBoolean("succeeded", true);
+          result.putString("recordingId", recordingId);
+          result.putString("filePath", myDir.getAbsolutePath());
+          Log.d(TAG, "recordingId: " + recordingId);
+        } else {
+          result.putBoolean("succeeded", false);
+          result.putString("errorCode", String.valueOf(e.getCode()));
+          result.putString("errorMessage", e.getMessage());
+          Log.d(TAG, "recording error: " + e.getMessage());
+        }
+        promise.resolve(result);
+      });
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void stopRecording(String recordingId, Promise promise) {
+    Log.d(TAG, "stopRecording: " + recordingId);
+    if (CALL_ACTIVE == null) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", "Cuộc gọi không tồn tại");
+      promise.resolve(result);
+      return;
+    }
+    
+    try {
+      boolean succeeded = CALL_ACTIVE.stopRecording(recordingId);
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", succeeded);
+      promise.resolve(result);
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  // MARK: - Push Token Management
+  @ReactMethod
+  public void registerPushToken(String token, Promise promise) {
+    if (SendBirdCall.getCurrentUser() != null) {
+      SendBirdCall.registerPushToken(token, false, e -> {
+        WritableMap result = Arguments.createMap();
+        if (e != null) {
+          Log.i(TAG, "registerPushToken error: " + e.getMessage());
+          result.putBoolean("succeeded", false);
+          result.putString("errorCode", String.valueOf(e.getCode()));
+          result.putString("errorMessage", e.getMessage());
+        } else {
+          result.putBoolean("succeeded", true);
+        }
+        promise.resolve(result);
+      });
+    } else {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", "User chưa được authenticate");
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void unregisterPushToken(String token, Promise promise) {
+    if (SendBirdCall.getCurrentUser() != null) {
+      SendBirdCall.unregisterPushToken(token, e -> {
+        WritableMap result = Arguments.createMap();
+        if (e == null) {
+          result.putBoolean("succeeded", true);
+        } else {
+          result.putBoolean("succeeded", false);
+          result.putString("errorCode", String.valueOf(e.getCode()));
+          result.putString("errorMessage", e.getMessage());
+        }
+        promise.resolve(result);
+      });
+    } else {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", "User chưa được authenticate");
+      promise.resolve(result);
+    }
+  }
+
+  // MARK: - Sound Configuration
+  @ReactMethod
+  public void setDirectCallDialingSoundOnWhenSilentMode(boolean isEnabled, Promise promise) {
+    try {
+      SendBirdCall.Options.setDirectCallDialingSoundOnWhenSilentOrVibrateMode(isEnabled);
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", true);
+      promise.resolve(result);
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void addDirectCallSound(String soundType, String filename) {
+    try {
+      Context context = mContext.getApplicationContext();
+      int resourceId = context.getResources().getIdentifier(filename, "raw", context.getPackageName());
+      
+      if (resourceId != 0) {
+        switch (soundType) {
+          case "DIALING":
+            SendBirdCall.Options.addDirectCallSound(SendBirdCall.SoundType.DIALING, resourceId);
+            break;
+          case "RINGING":
+            SendBirdCall.Options.addDirectCallSound(SendBirdCall.SoundType.RINGING, resourceId);
+            break;
+          case "RECONNECTING":
+            SendBirdCall.Options.addDirectCallSound(SendBirdCall.SoundType.RECONNECTING, resourceId);
+            break;
+          case "RECONNECTED":
+            SendBirdCall.Options.addDirectCallSound(SendBirdCall.SoundType.RECONNECTED, resourceId);
+            break;
+        }
+      }
+    } catch (Exception e) {
+      Log.e(TAG, "addDirectCallSound error: " + e.getMessage());
+    }
+  }
+
+  // MARK: - Event Management
+  @ReactMethod
+  public void setNativeEvent(String event) {
+    if (!JS_EVENTS.contains(event)) {
+      JS_EVENTS.add(event);
+    }
+    
+    // Handle pending events
+    if ("onRinging".equals(event) 
+        && !IS_SEND_EVENT_RINGING 
+        && !IS_CALL_ACCEPTED 
+        && !IS_CALL_CONNECTED 
+        && CALL_ACTIVE != null) {
+      sendEvent(mContext, "onRinging", CALL_ACTIVE);
+      IS_SEND_EVENT_RINGING = true;
+    }
+  }
+
+  @ReactMethod
+  public void removeNativeEvent(String event) {
+    JS_EVENTS.remove(event);
+  }
+
+  @ReactMethod
+  public void removeAllEvents() {
+    JS_EVENTS.clear();
+    SendBirdCall.removeAllListeners();
+    SendBirdCall.removeAllRecordingListeners();
+  }
+
+  // MARK: - Utility Methods
+  public static String getAppId(Context context) {
+    SharedPreferences shareReference = context.getSharedPreferences("EDOCTOR_NATIVE", Context.MODE_PRIVATE);
+    return shareReference.getString("ANDROID_APP_ID", "");
+  }
+
+  public static void endCalls() {
+    try {
+      List<DirectCall> directCalls = SendBirdCall.getOngoingCalls();
+      if (directCalls != null && !directCalls.isEmpty()) {
+        for (DirectCall call : directCalls) {
+          call.end();
+        }
+      }
+    } catch (Exception e) {
+      Log.d(TAG, "endCalls error: " + e.getMessage());
+    }
+  }
+
+  // MARK: - Call Listener Setup
+  private static void handleListenerSendBirdCall(DirectCall mDirectCall) {
+    if (mDirectCall == null) return;
+    CALL_ACTIVE = mDirectCall;
+    
+    mDirectCall.setListener(new DirectCallListener() {
+      @Override
+      public void onEstablished(@NotNull DirectCall directCall) {
+        Log.i(TAG, "onEstablished");
+        IS_CALL_ACCEPTED = true;
+        sendEvent(mContext, "onCallDidAccept", directCall);
+      }
+
+      @Override
+      public void onConnected(@NotNull DirectCall directCall) {
+        Log.i(TAG, "onConnected");
+        IS_CALL_CONNECTED = true;
+        sendEvent(mContext, "onConnected", directCall);
+      }
+
+      @Override
+      public void onEnded(@NotNull DirectCall directCall) {
+        Log.i(TAG, "onEnded");
+        sendEvent(mContext, "onEnded", directCall);
+        IS_CALL_ACCEPTED = false;
+        IS_CALL_CONNECTED = false;
+        IS_SEND_EVENT_RINGING = false;
+        CALL_ACTIVE = null;
+      }
+
+      @Override
+      public void onReconnected(@NonNull DirectCall directCall) {
+        Log.i(TAG, "onReconnected");
+        sendEvent(mContext, "onReconnected", directCall);
+      }
+
+      @Override
+      public void onReconnecting(@NonNull DirectCall directCall) {
+        Log.i(TAG, "onReconnecting");
+        sendEvent(mContext, "onReconnecting", directCall);
+      }
+
+      @Override
+      public void onRemoteAudioSettingsChanged(DirectCall directCall) {
+        Log.i(TAG, "onRemoteAudioSettingsChanged");
+        sendEvent(mContext, "onRemoteAudioSettingsChanged", directCall);
+      }
+
+      @Override
+      public void onRemoteVideoSettingsChanged(DirectCall directCall) {
+        Log.i(TAG, "onRemoteVideoSettingsChanged");
+        sendEvent(mContext, "onRemoteVideoSettingsChanged", directCall);
+      }
+    });
+  }
+
+  // MARK: - Event Emission
+  public static void sendEvent(ReactContext reactContext, String eventName, DirectCall directCall) {
+    if (!JS_EVENTS.contains(eventName) || reactContext == null) return;
+    
+    try {
+      WritableMap params = getParamDirectCall(directCall);
+      reactContext
+          .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+          .emit(eventName, params);
+    } catch (Exception e) {
+      Log.e(TAG, "Error sending event " + eventName + ": " + e.getMessage());
+    }
+  }
+
+  // MARK: - Firebase Integration
+  public static void onMessageReceived(Context context, Map<String, String> data) {
+    setupSoundEffects(context);
+    SendBirdCall.handleFirebaseMessageData(data);
+  }
+
+  public static void onNewToken(String token) {
+    if (SendBirdCall.getCurrentUser() != null) {
+      SendBirdCall.registerPushToken(token, false, e -> {
+        if (e != null) {
+          Log.i(TAG, "[FirebaseMessagingService] onNewToken() error: " + e.getMessage());
+        }
+      });
+    }
+  }
+
+  // MARK: - Sound Effects Setup
+  static public void setUpSoundEffects(
+      @Nullable Integer ringingId,
+      @Nullable Integer dialingId,
+      @Nullable Integer connectingId,
+      @Nullable Integer connectedId
+  ) {
+    try {
+      if (ringingId != null && ringingId != 0)
+        SendBirdCall.Options.addDirectCallSound(SendBirdCall.SoundType.RINGING, ringingId);
+      if (dialingId != null && dialingId != 0)
+        SendBirdCall.Options.addDirectCallSound(SendBirdCall.SoundType.DIALING, dialingId);
+      if (connectingId != null && connectingId != 0)
+        SendBirdCall.Options.addDirectCallSound(SendBirdCall.SoundType.RECONNECTING, connectingId);
+      if (connectedId != null && connectedId != 0)
+        SendBirdCall.Options.addDirectCallSound(SendBirdCall.SoundType.RECONNECTED, connectedId);
+      
+      SendBirdCall.Options.setDirectCallDialingSoundOnWhenSilentOrVibrateMode(true);
+    } catch (Exception e) {
+      Log.e(TAG, "setUpSoundEffects error: " + e.getMessage());
+    }
+  }
+
+  // MARK: - Legacy Methods (for backward compatibility)
+  @ReactMethod
+  public void getCall(String callId, Promise promise) {
+    try {
+      DirectCall directCall = SendBirdCall.getCall(callId);
+      if (directCall != null) {
+        WritableMap callInfo = getParamDirectCall(directCall);
+        callInfo.putBoolean("succeeded", true);
+        promise.resolve(callInfo);
+      } else {
+        WritableMap result = Arguments.createMap();
+        result.putBoolean("succeeded", false);
+        result.putString("errorMessage", "Cuộc gọi không tồn tại");
+        promise.resolve(result);
+      }
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void endIncomingCallNeedAuthentication(String callId, Promise promise) {
+    Log.i(TAG, "endIncomingCallNeedAuthentication");
+    try {
+      DirectCall mDirectCall = SendBirdCall.getCall(callId);
+      if (mDirectCall != null) {
+        DirectCallUser callee = mDirectCall.getCallee();
+        AuthenticateParams params = new AuthenticateParams(callee.getUserId());
+        SendBirdCall.authenticate(params, (user, e) -> {
+          WritableMap result = Arguments.createMap();
+          if (e == null) {
+            mDirectCall.end();
+            IS_CALL_ACCEPTED = false;
+            IS_CALL_CONNECTED = false;
+            result.putBoolean("succeeded", true);
+          } else {
+            result.putBoolean("succeeded", false);
+            result.putString("errorCode", String.valueOf(e.getCode()));
+            result.putString("errorMessage", e.getMessage());
+          }
+          promise.resolve(result);
+        });
+      } else {
+        WritableMap result = Arguments.createMap();
+        result.putBoolean("succeeded", false);
+        result.putString("errorMessage", "Cuộc gọi không tồn tại");
+        promise.resolve(result);
+      }
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void acceptIncomingCallNeedAuthentication(String callId, boolean isVideoEnable, boolean isAudioEnable, Promise promise) {
+    Log.i(TAG, "acceptIncomingCallNeedAuthentication");
+    try {
+      DirectCall mDirectCall = SendBirdCall.getCall(callId);
+      if (mDirectCall != null) {
+        DirectCallUser callee = mDirectCall.getCallee();
+        AuthenticateParams params = new AuthenticateParams(callee.getUserId());
+        SendBirdCall.authenticate(params, (user, e) -> {
+          WritableMap result = Arguments.createMap();
+          if (e == null) {
+            handleListenerSendBirdCall(mDirectCall);
+            CallOptions callOptions = new CallOptions()
+                .setVideoEnabled(isVideoEnable)
+                .setAudioEnabled(isAudioEnable);
+            mDirectCall.accept(new AcceptParams().setCallOptions(callOptions));
+            IS_CALL_ACCEPTED = true;
+            result.putBoolean("succeeded", true);
+          } else {
+            result.putBoolean("succeeded", false);
+            result.putString("errorCode", String.valueOf(e.getCode()));
+            result.putString("errorMessage", e.getMessage());
+          }
+          promise.resolve(result);
+        });
+      } else {
+        WritableMap result = Arguments.createMap();
+        result.putBoolean("succeeded", false);
+        result.putString("errorMessage", "Cuộc gọi không tồn tại");
+        promise.resolve(result);
+      }
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void wakeAppIncomingCall(ReadableMap params) {
+    Log.d(TAG, "wakeAppIncomingCall");
+    try {
+      Bundle bundle = Arguments.toBundle(params);
+      Intent intent = new Intent(mContext.getApplicationContext(), VoIPService.class);
+      intent.putExtras(bundle);
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        mContext.getApplicationContext().startForegroundService(intent);
+      } else {
+        mContext.getApplicationContext().startService(intent);
+      }
+    } catch (Exception e) {
+      Log.e(TAG, "wakeAppIncomingCall error: " + e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void navigateMainApp(ReadableMap params) {
+    Log.d(TAG, "navigateMainApp");
+    try {
+      Bundle bundle = Arguments.toBundle(params);
+      SharedUtils.navigateMainApp(mContext.getApplicationContext(), bundle);
+    } catch (Exception e) {
+      Log.e(TAG, "navigateMainApp error: " + e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void finishLockedScreenUI() {
+    try {
+      if (mContext.getCurrentActivity() != null) {
+        mContext.getCurrentActivity().finish();
+      }
+    } catch (Exception e) {
+      Log.e(TAG, "finishLockedScreenUI error: " + e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void getDeviceLocked(Promise promise) {
+    try {
+      boolean isLocked = SharedUtils.getDeviceLocked(mContext.getApplicationContext());
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", true);
+      result.putBoolean("isLocked", isLocked);
+      promise.resolve(result);
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void cancelComingCallNotification() {
+    try {
+      SharedUtils.cancelComingCallNotification();
+    } catch (Exception e) {
+      Log.e(TAG, "cancelComingCallNotification error: " + e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void isAppInForeground(Promise promise) {
+    try {
+      boolean isInForeground = SharedUtils.isAppInForeground(mContext.getApplicationContext());
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", true);
+      result.putBoolean("isInForeground", isInForeground);
+      promise.resolve(result);
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+
+  @ReactMethod
+  public void getCallInfo(Promise promise) {
+    try {
+      if (CALL_ACTIVE == null) {
+        promise.resolve(null);
+        return;
+      }
+      
+      DirectCall directCall = SendBirdCall.getCall(CALL_ACTIVE.getCallId());
+      if (directCall == null) {
+        promise.resolve(null);
+      } else {
+        Log.d(TAG, "getCallInfo: " + directCall.getCallId());
+        WritableMap callInfo = getParamDirectCall(directCall);
+        callInfo.putBoolean("succeeded", true);
+        promise.resolve(callInfo);
+      }
+    } catch (Exception e) {
+      WritableMap result = Arguments.createMap();
+      result.putBoolean("succeeded", false);
+      result.putString("errorMessage", e.getMessage());
+      promise.resolve(result);
+    }
+  }
+}