edoctor-sendbird-calls 1.0.0

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

@@ -0,0 +1,32 @@
+package com.rnsendbirdcalls;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class RNSendBirdCallsPackage implements ReactPackage {
+    
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new RNSendBirdCallsModule(reactContext));
+        return modules;
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        List<ViewManager> viewManagers = new ArrayList<>();
+        // Uncomment if you have video view manager
+        viewManagers.add(new RNVSendBirdCallsVideoManager());
+        return viewManagers;
+    }
+}

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

@@ -0,0 +1,10 @@
+package com.rnsendbirdcalls;
+
+import com.facebook.react.uimanager.ThemedReactContext;
+
+public class RNVSendBirdCallsVideo extends RNVideoViewGroup {
+
+    public RNVSendBirdCallsVideo(ThemedReactContext themedReactContext) {
+        super(themedReactContext);
+    }
+}

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

@@ -0,0 +1,77 @@
+package com.rnsendbirdcalls;
+
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.sendbird.calls.DirectCall;
+import com.sendbird.calls.SendBirdCall;
+import com.sendbird.calls.SendBirdVideoView;
+
+import org.jetbrains.annotations.NotNull;
+import org.webrtc.RendererCommon;
+
+public class RNVSendBirdCallsVideoManager extends ViewGroupManager<RNVSendBirdCallsVideo> {
+
+    private int propWidth;
+    private int propHeight;
+    private String curCallId;
+    private DirectCall directCall;
+
+    @NotNull
+    @Override
+    public String getName() {
+        return "RNVSendBirdCallsVideo";
+    }
+
+    @NonNull
+    @NotNull
+    @Override
+    protected RNVSendBirdCallsVideo createViewInstance(@NonNull @NotNull ThemedReactContext reactContext) {
+        return new RNVSendBirdCallsVideo(reactContext);
+    }
+
+    @ReactProp(name = "callId")
+    public void callId(RNVSendBirdCallsVideo view, @Nullable String callId) {
+        if(callId.length() > 0) {
+            curCallId = callId;
+            directCall = SendBirdCall.getCall(callId);
+        }
+    }
+
+    @ReactProp(name = "local", defaultBoolean = false)
+    public void local(RNVSendBirdCallsVideo view, @Nullable Boolean local) {
+        SendBirdVideoView videoView = view.getSurfaceViewRenderer();
+        if(directCall == null) return;
+        if(local) {
+            directCall.setLocalVideoView(videoView);
+        }else {
+            directCall.setRemoteVideoView(videoView);
+        }
+    }
+
+    @ReactProp(name = "scaleFit", defaultBoolean = true)
+    public void scaleFit(RNVSendBirdCallsVideo view, @Nullable Boolean scaleFit) {
+        SendBirdVideoView videoView = view.getSurfaceViewRenderer();
+        if(directCall == null) return;
+        if(scaleFit) {
+            view.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FIT);
+        }else {
+            view.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FILL);
+        }
+    }
+
+    public void manuallyLayoutChildren(View view) {
+        // propWidth and propHeight coming from react-native props
+        int width = propWidth;
+        int height = propHeight;
+        view.measure(
+                View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
+                View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY));
+        view.layout(0, 0, width, height);
+    }
+}

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

@@ -0,0 +1,109 @@
+package com.rnsendbirdcalls;
+
+import android.graphics.Point;
+import android.view.ViewGroup;
+
+import androidx.annotation.StringDef;
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.sendbird.calls.SendBirdVideoView;
+
+import org.webrtc.RendererCommon;
+
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import static com.rnsendbirdcalls.RNVideoViewGroup.Events.ON_FRAME_DIMENSIONS_CHANGED;
+
+public class RNVideoViewGroup extends ViewGroup {
+    private SendBirdVideoView surfaceViewRenderer = null;
+    private int videoWidth = 0;
+    private int videoHeight = 0;
+    private final Object layoutSync = new Object();
+    private RendererCommon.ScalingType scalingType = RendererCommon.ScalingType.SCALE_ASPECT_FIT;
+
+    @Retention(RetentionPolicy.SOURCE)
+    @StringDef({ON_FRAME_DIMENSIONS_CHANGED})
+    public @interface Events {
+        String ON_FRAME_DIMENSIONS_CHANGED = "onFrameDimensionsChanged";
+    }
+
+    public RNVideoViewGroup(ThemedReactContext themedReactContext) {
+        super(themedReactContext);
+        surfaceViewRenderer = new SendBirdVideoView(themedReactContext);
+        surfaceViewRenderer.setEnableHardwareScaler(true);
+        addView(surfaceViewRenderer);
+
+//        surfaceViewRenderer.setListener(
+//                new RendererCommon.RendererEvents() {
+//                    @Override
+//                    public void onFirstFrameRendered() {
+//
+//                    }
+//
+//                    @Override
+//                    public void onFrameResolutionChanged(int vw, int vh, int rotation) {
+//                        synchronized (layoutSync) {
+//                            if (rotation == 90 || rotation == 270) {
+//                                videoHeight = vw;
+//                                videoWidth = vh;
+//                            } else {
+//                                videoHeight = vh;
+//                                videoWidth = vw;
+//                            }
+//                            RNVideoViewGroup.this.forceLayout();
+//
+//                            WritableMap event = new WritableNativeMap();
+//                            event.putInt("height", vh);
+//                            event.putInt("width", vw);
+//                            event.putInt("rotation", rotation);
+//                            pushEvent(RNVideoViewGroup.this, ON_FRAME_DIMENSIONS_CHANGED, event);
+//                        }
+//                    }
+//                }
+//        );
+    }
+
+    public SendBirdVideoView getSurfaceViewRenderer() {
+        return surfaceViewRenderer;
+    }
+
+    public void setScalingType(RendererCommon.ScalingType scalingType) {
+        this.scalingType = scalingType;
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        int height = b - t;
+        int width = r - l;
+        if (height == 0 || width == 0) {
+            l = t = r = b = 0;
+        } else {
+            int videoHeight;
+            int videoWidth;
+            synchronized (layoutSync) {
+                videoHeight = this.videoHeight;
+                videoWidth = this.videoWidth;
+            }
+
+            if (videoHeight == 0 || videoWidth == 0) {
+                videoHeight = 480;
+                videoWidth = 640;
+            }
+
+            Point displaySize = RendererCommon.getDisplaySize(
+                    this.scalingType,
+                    videoWidth / (float) videoHeight,
+                    width,
+                    height
+            );
+
+            l = (width - displaySize.x) / 2;
+            t = (height - displaySize.y) / 2;
+            r = l + displaySize.x;
+            b = t + displaySize.y;
+        }
+        surfaceViewRenderer.layout(l, t, r, b);
+    }
+}

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

@@ -0,0 +1,127 @@
+package com.rnsendbirdcalls;
+
+import android.annotation.SuppressLint;
+import android.app.ActivityManager;
+import android.app.KeyguardManager;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.PowerManager;
+import android.util.Log;
+
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.common.LifecycleState;
+
+import java.util.List;
+
+@SuppressWarnings({"unused", "JavaDoc", "WeakerAccess"})
+public class SharedUtils {
+    /**
+     * We need to check if app is in foreground otherwise the app will crash.
+     * http://stackoverflow.com/questions/8489993/check-android-application-is-in-foreground-or-not
+     *
+     * @param context Context
+     * @return boolean
+     */
+    public static boolean isAppInForeground(Context context) {
+        ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+        if (activityManager == null) return false;
+
+        List<ActivityManager.RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
+        if (appProcesses == null) return false;
+
+        final String packageName = context.getPackageName();
+        for (ActivityManager.RunningAppProcessInfo appProcess : appProcesses) {
+            if (
+                    appProcess.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
+                            && appProcess.processName.equals(packageName)
+            ) {
+                ReactContext reactContext;
+
+                try {
+                    reactContext = (ReactContext) context;
+                } catch (ClassCastException exception) {
+                    // Not react context so default to true
+                    return true;
+                }
+
+                return reactContext.getLifecycleState() == LifecycleState.RESUMED;
+            }
+        }
+
+        return false;
+    }
+
+    public static boolean getDeviceLocked(Context context) {
+        boolean isLocked = false;
+        // First we check the locked state
+        KeyguardManager keyguardManager = (KeyguardManager) context.getSystemService(context.KEYGUARD_SERVICE);
+        boolean inKeyguardRestrictedInputMode = keyguardManager.inKeyguardRestrictedInputMode();
+        if (inKeyguardRestrictedInputMode) {
+            isLocked = true;
+        } else {
+            // If password is not set in the settings, the inKeyguardRestrictedInputMode() returns false,
+            // so we need to check if screen on for this case
+            PowerManager powerManager = (PowerManager) context.getSystemService(context.POWER_SERVICE);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH) {
+                isLocked = !powerManager.isInteractive();
+            } else {
+                //noinspection deprecation
+                isLocked = !powerManager.isScreenOn();
+            }
+        }
+        return isLocked;
+    }
+
+    public static Class<?> getMainActivityClass(Context appContext){
+        try {
+            final Package appPackage = appContext.getClass().getPackage();
+            assert appPackage != null;
+            final String className = appPackage.getName() + ".MainActivity";
+            return Class.forName(className);
+        } catch (Exception e){
+            e.printStackTrace();
+        }
+        return  null;
+    }
+
+    public static void navigateMainApp(Context context, Bundle bundle) {
+        try {
+            Intent intent = new Intent(context, getMainActivityClass(context));
+            intent.putExtras(bundle);
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
+            context.startActivity(intent);
+            cancelComingCallNotification();
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+
+    public static void startComingCallActivity(Context context, Bundle bundle) {
+        try {
+            Intent intent = new Intent(context, ComingCallActivity.class);
+            intent.putExtras(bundle);
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+            context.startActivity(intent);
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+
+    public static void cancelComingCallNotification(){
+        VoIPBaseService instance = VoIPService.getSharedInstance();
+        if(instance != null) {
+            instance.stopSelf();
+        }
+    }
+
+    @SuppressLint("PrivateApi")
+    public static String getSystemProperty(String key) {
+        try {
+            Class props = Class.forName("android.os.SystemProperties");
+            return (String) props.getMethod("get", String.class).invoke(null, key);
+        } catch (Exception ignore) {  }
+        return null;
+    }
+}

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

@@ -0,0 +1,37 @@
+package com.rnsendbirdcalls;
+
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+
+import com.facebook.react.HeadlessJsTaskService;
+
+public class VcCallReceiver extends BroadcastReceiver {
+
+    private void acceptIncomingCallFromNotification(Context context, Bundle extras) {
+        extras.putString("CALL_STATUS", "ANSWERED");
+        SharedUtils.navigateMainApp(context, extras);
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        Bundle extras = intent.getExtras();
+        if ((context.getPackageName() + ".DECLINE_CALL").equals(intent.getAction())) {
+            if(extras != null) extras.putString("ACTION", "DENIED");
+        } else if ((context.getPackageName() + ".ANSWER_CALL").equals(intent.getAction())) {
+            if(extras != null) extras.putString("ACTION", "ACCEPT");
+            acceptIncomingCallFromNotification(context.getApplicationContext(), extras);
+        }
+
+        Intent serviceIntent = new Intent(context, VcHeadlessService.class);
+        serviceIntent.putExtras(extras);
+        context.startService(serviceIntent);
+        HeadlessJsTaskService.acquireWakeLockNow(context);
+
+        if (VoIPBaseService.getSharedInstance() != null) {
+            VoIPBaseService.getSharedInstance().stopSelf();
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+package com.rnsendbirdcalls;
+
+import android.content.Intent;
+import android.os.Bundle;
+
+import com.facebook.react.HeadlessJsTaskService;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.jstasks.HeadlessJsTaskConfig;
+import javax.annotation.Nullable;
+
+public class VcHeadlessService extends HeadlessJsTaskService {
+
+    @Override
+    protected @Nullable HeadlessJsTaskConfig getTaskConfig(Intent intent) {
+        Bundle extras = intent.getExtras();
+        return new HeadlessJsTaskConfig(
+                "VcHeadlessService",
+                Arguments.fromBundle(extras),
+                60000, // timeout for the task
+                true // optional: defines whether or not  the task is allowed in foreground. Default is false
+        );
+    }
+}

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

@@ -0,0 +1,100 @@
+package com.rnsendbirdcalls;
+
+import android.annotation.SuppressLint;
+import android.app.KeyguardManager;
+import android.app.NotificationManager;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.os.Build;
+import android.os.PowerManager;
+import android.telephony.TelephonyManager;
+import android.util.Log;
+
+import androidx.core.app.NotificationManagerCompat;
+
+@SuppressLint("NewApi")
+public abstract class VoIPBaseService extends Service {
+
+    private String TAG = "VOIP_BASE_SERVICE_TAG";
+
+    protected static final int ID_INCOMING_CALL_NOTIFICATION = 202;
+
+    protected static final String NOTIFICATION_CHANNEL = "edoctor_call_channel";
+
+    protected static final boolean USE_CONNECTION_SERVICE = isDeviceCompatibleWithConnectionServiceAPI();
+
+    protected static VoIPBaseService sharedInstance;
+    protected boolean notificationsDisabled = false;
+    protected PowerManager.WakeLock proximityWakelock;
+    protected PowerManager.WakeLock cpuWakelock;
+
+    public static VoIPBaseService getSharedInstance() { return sharedInstance; }
+
+    @Override
+    public void onDestroy() {
+        Log.d(TAG, "======== VoIP SERVICE STOPPING ========");
+        stopForeground(true);
+        if (proximityWakelock != null && proximityWakelock.isHeld()) {
+            proximityWakelock.release();
+        }
+        NotificationManager manager = (NotificationManager) this.getSystemService(Context.NOTIFICATION_SERVICE);
+        manager.cancel(ID_INCOMING_CALL_NOTIFICATION);
+        super.onDestroy();
+        if (cpuWakelock != null && cpuWakelock.isHeld()) {
+            cpuWakelock.release();
+        }
+        sharedInstance = null;
+    }
+
+    @SuppressLint("InvalidWakeLockTag")
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        Log.d(TAG, "======== VoIP SERVICE STARTING ========");
+        try {
+            cpuWakelock = ((PowerManager) getSystemService(POWER_SERVICE)).newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "edoctor-voip");
+            cpuWakelock.acquire();
+            IntentFilter filter = new IntentFilter();
+            filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
+            if (!USE_CONNECTION_SERVICE) {
+                filter.addAction(TelephonyManager.ACTION_PHONE_STATE_CHANGED);
+                filter.addAction(Intent.ACTION_SCREEN_ON);
+                filter.addAction(Intent.ACTION_SCREEN_OFF);
+            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && !NotificationManagerCompat.from(this.getApplicationContext()).areNotificationsEnabled()) {
+                notificationsDisabled = true;
+            }
+        } catch (Exception x) { }
+    }
+
+    protected boolean isAcknowledgeCall(){
+        boolean isAcknowledge = true;
+        if (Build.VERSION.SDK_INT >= 19 && XiaomiUtilities.isMIUI() && !XiaomiUtilities.isCustomPermissionGranted(this.getApplicationContext(), XiaomiUtilities.OP_SHOW_WHEN_LOCKED)) {
+            if (((KeyguardManager) getSystemService(KEYGUARD_SERVICE)).inKeyguardRestrictedInputMode()) {
+                Log.d(TAG, "MIUI: no permission to show when locked but the screen is locked. ¯\\_(ツ)_/¯");
+                isAcknowledge = false;
+            }
+        }
+        return isAcknowledge;
+    }
+
+    private static boolean isDeviceCompatibleWithConnectionServiceAPI() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            return false;
+        }
+        // some non-Google devices don't implement the ConnectionService API correctly so, sadly,
+        // we'll have to whitelist only a handful of known-compatible devices for now
+        return false;/*"angler".equals(Build.PRODUCT)            // Nexus 6P
+				|| "bullhead".equals(Build.PRODUCT)        // Nexus 5X
+				|| "sailfish".equals(Build.PRODUCT)        // Pixel
+				|| "marlin".equals(Build.PRODUCT)        // Pixel XL
+				|| "walleye".equals(Build.PRODUCT)        // Pixel 2
+				|| "taimen".equals(Build.PRODUCT)        // Pixel 2 XL
+				|| "blueline".equals(Build.PRODUCT)        // Pixel 3
+				|| "crosshatch".equals(Build.PRODUCT)    // Pixel 3 XL
+				|| MessagesController.getGlobalMainSettings().getBoolean("dbg_force_connection_service", false);*/
+    }
+}

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

@@ -0,0 +1,164 @@
+package com.rnsendbirdcalls;
+
+import android.annotation.SuppressLint;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.text.SpannableString;
+import android.text.style.ForegroundColorSpan;
+import android.util.Log;
+import android.widget.RemoteViews;
+
+import androidx.annotation.Nullable;
+
+@SuppressLint("NewApi")
+public class VoIPService extends VoIPBaseService {
+
+    private String TAG = "VOIP_SERVICE_TAG";
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        sharedInstance = this;
+        if(!isAcknowledgeCall()) { stopSelf(); return START_NOT_STICKY; }
+        Bundle bundle =  intent.getExtras();
+        if (!notificationsDisabled && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            showIncomingNotification(bundle);
+        } else {
+            SharedUtils.navigateMainApp(this, bundle);
+        }
+        return START_NOT_STICKY;
+    }
+
+    protected void showIncomingNotification(Bundle bundle) {
+        String notificationTitle = bundle.getString("title");
+        if(notificationTitle == null) notificationTitle = "Cuộc gọi đến";
+        else bundle.remove("title");
+
+        String notificationDescription = bundle.getString("description");
+        if(notificationDescription == null) notificationDescription = "...";
+        else bundle.remove("description");
+
+        long timeoutAfter = (long)bundle.getDouble("timeoutAfter");
+        if(timeoutAfter == 0) timeoutAfter = 60000;
+        else bundle.remove("timeoutAfter");
+
+        Intent intentComingCall;
+        Boolean isDeviceLocked = SharedUtils.getDeviceLocked(this.getApplicationContext());
+        Log.d(TAG, "isDeviceLocked: isDeviceLocked" + isDeviceLocked);
+        if (isDeviceLocked) {
+            intentComingCall = new Intent(this, ComingCallActivity.class).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                    .putExtras(bundle);
+        } else {
+             intentComingCall = new Intent(this, SharedUtils.getMainActivityClass(this.getApplicationContext())).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                    .putExtras(bundle);
+        }
+
+
+        Notification.Builder builder = new Notification.Builder(this)
+                .setContentTitle(notificationTitle)
+                .setContentText(notificationDescription)
+                .setSmallIcon(android.R.drawable.sym_action_call)
+                .setAutoCancel(true)
+                .setPriority(Notification.PRIORITY_MAX)
+                .setOngoing(true)
+                .setShowWhen(true)
+                .setContentIntent(
+                        PendingIntent.getActivity(
+                                this,
+                                0,
+                                intentComingCall,
+                                PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT
+                        )
+                );
+
+        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.N) {
+            builder.setTimeoutAfter(timeoutAfter);
+        }
+
+        // create channel android sdk >= 26
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            NotificationManager NMmanager = (NotificationManager) this.getSystemService(Context.NOTIFICATION_SERVICE);
+            if (NMmanager.getNotificationChannel(NOTIFICATION_CHANNEL) == null) {
+                NMmanager.createNotificationChannel(
+                        new NotificationChannel(NOTIFICATION_CHANNEL, "Nhận cuộc gọi", NotificationManager.IMPORTANCE_HIGH)
+                );
+            }
+            builder.setChannelId(NOTIFICATION_CHANNEL);
+        }
+
+        // create end PendingIntent
+        Intent endIntent = new Intent(this, VcCallReceiver.class).putExtras(bundle);
+        endIntent.setAction(getPackageName() + ".DECLINE_CALL");
+        CharSequence endTitle = "Từ chối";
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            endTitle = new SpannableString(endTitle);
+            ((SpannableString) endTitle).setSpan(new ForegroundColorSpan(0xFFF44336), 0, endTitle.length(), 0);
+        }
+        PendingIntent endPendingIntent = PendingIntent.getBroadcast(
+                this,
+                0,
+                endIntent,
+                PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT
+        );
+        builder.addAction(R.drawable.button_reject, endTitle, endPendingIntent);
+        // create end PendingIntent
+
+        // create answer PendingIntent
+        Intent answerIntent = new Intent(this, SharedUtils.getMainActivityClass(this.getApplicationContext())).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                                                                   .putExtras(bundle);
+        answerIntent.setAction(getPackageName() + ".ANSWER_CALL");
+        CharSequence answerTitle = "Đồng ý";
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            answerTitle = new SpannableString(answerTitle);
+            ((SpannableString) answerTitle).setSpan(new ForegroundColorSpan(0xFF00AA00), 0, answerTitle.length(), 0);
+        }
+        PendingIntent answerPendingIntent = PendingIntent.getActivity(
+                                                                            this,
+                                                                            0,
+                                                                            answerIntent,
+                                                                            PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT
+                                                                    );
+
+        builder.addAction(R.drawable.button_answer, answerTitle, answerPendingIntent);
+        // create answer PendingIntent
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+            builder.setShowWhen(false);
+        }
+
+        Notification incomingNotification = builder.getNotification();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            builder.setCategory(Notification.CATEGORY_CALL);
+            PendingIntent fullScreenPendingIntent = PendingIntent.getActivity(
+                    this,
+                    0,
+                    intentComingCall,
+                    PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT
+            );
+            builder.setFullScreenIntent(fullScreenPendingIntent, true);
+            RemoteViews customView = new RemoteViews(getPackageName(), R.layout.call_notification);
+            customView.setTextViewText(R.id.title, notificationTitle);
+            customView.setTextViewText(R.id.subtitle, notificationDescription);
+            customView.setTextViewText(R.id.answer_text, "Đồng ý");
+            customView.setTextViewText(R.id.decline_text, "Từ chối");
+            customView.setOnClickPendingIntent(R.id.container, fullScreenPendingIntent);
+            customView.setOnClickPendingIntent(R.id.answer_btn, answerPendingIntent);
+            customView.setOnClickPendingIntent(R.id.decline_btn, endPendingIntent);
+            incomingNotification.headsUpContentView = incomingNotification.bigContentView = customView;
+        }
+        startForeground(ID_INCOMING_CALL_NOTIFICATION, incomingNotification);
+    }
+
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+}