allprojects {
    repositories {
        mavenCentral()
    }
}

implementation 'com.google.firebase:firebase-messaging:21.0.0'

implementation('io.socket:socket.io-client:2.1.0') {
        exclude group: 'org.json', module: 'json'
}

implementation 'com.github.bumptech.glide:glide:4.12.0'

implementation 'androidx.work:work-runtime:2.7.1'

implementation 'androidx.constraintlayout:constraintlayout:2.1.3'

android {
	compileOptions {
		sourceCompatibility JavaVersion.VERSION_1_8
		targetCompatibility JavaVersion.VERSION_1_8
	}
}

SignedCallInitResponse signedCallInitListener = new SignedCallInitResponse() {
      @Override
      public void onSuccess() {
          //App is notified on the main thread when the Signed Call SDK is initialized
      }

      @Override
      public void onFailure(@NonNull InitException initException) {
          //App is notified on the main thread when the initialization is failed
          Log.d("SignedCall: ", "error code: " + initException.getErrorCode()
                 + "\n error message: " + initException.getMessage()
                 + "\n error explanation: " + initException.getExplanation());

          if (initException.getErrorCode() == InitException.SdkNotInitializedException.getErrorCode()) {
             //Handle this error here
          }
      }
};

//Create a Builder instance of SignedCallInitConfiguration and pass it inside the init() method
SignedCallInitConfiguration initConfiguration = new SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
         .build();

SignedCallAPI.getInstance().init(getApplicationContext(), initConfiguration, cleverTapAPI, signedCallInitListener);

val signedCallInitListener: SignedCallInitResponse = object : SignedCallInitResponse {
    override fun onSuccess() {
        //App is notified on the main thread when the Signed Call SDK is initialized
    }

    override fun onFailure(initException: InitException) {
        //App is notified on the main thread when the initialization is failed
        Log.d("SignedCall: ", "error code: " + initException.errorCode
                 + "\n error message: " + initException.message
                 + "\n error explanation: " + initException.explanation)

        if (initException.errorCode == InitException.SdkNotInitializedException.errorCode) 
        {
           //Handle this error here
        }
    }
}

//Create a Builder instance of SignedCallInitConfiguration and pass it inside the init() method
val initConfiguration = SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
    .build()

SignedCallAPI.getInstance().init(applicationContext, initConfiguration, cleverTapAPI, signedCallInitListener)

JSONObject initOptions = new JSONObject();
try {
    initOptions.put("accountId", <string>);
    initOptions.put("apiKey", <string>);
    initOptions.put("cuid", <string>);
    initOptions.put("appId", <string / optional>);
    initOptions.put("name", <string / optional>);
    initOptions.put("ringtone", <string / optional>);
} catch (JSONException e) {
    e.printStackTrace();
}

val initOptions = JSONObject();
try {
    initOptions.put("accountId", <string>);
    initOptions.put("apiKey", <string>);
    initOptions.put("cuid", <string>);
    initOptions.put("appId", <string / optional>);
    initOptions.put("name", <string / optional>);
    initOptions.put("ringtone", <string / optional>);
} catch (e: JSONException) {
    e.printStackTrace();
}

SignedCallInitConfiguration initConfiguration = new SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
         .promptReceiverReadPhoneStatePermission(<pass boolean here>)
         .build();

SignedCallAPI.getInstance().init(getApplicationContext(), initConfiguration, cleverTapAPI, signedCallInitListener)

val initConfiguration = SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
        .promptReceiverReadPhoneStatePermission(<pass boolean here>)
        .build()

SignedCallAPI.getInstance().init(applicationContext, initConfiguration, cleverTapAPI, signedCallInitListener)

CleverTapAPI.setSignedCallNotificationHandler(new SignedCallNotificationHandler());

CleverTapAPI.setSignedCallNotificationHandler(SignedCallNotificationHandler())

public class MyFcmMessageListenerService extends FirebaseMessagingService {
    @Override
    public void onMessageReceived(RemoteMessage message){
        new CTFcmMessageHandler().createNotification(getApplicationContext(), message);
    }
}

class MyFcmMessageListenerService : FirebaseMessagingService() {

    override fun onMessageReceived(message: RemoteMessage) {
        super.onMessageReceived(message)
        CTFcmMessageHandler().createNotification(applicationContext, message)
    }
}

FCMProcessingNotification fcmProcessingNotification = null;
try {
    fcmProcessingNotification = new FCMProcessingNotification.Builder(notiTitle, notiSubtitle)
            .setLargeIcon(fcmNotificationLargeIcon)
            .setCancelCtaLabel(cancelCta)
            .build();
  
} catch (Exception e) {
    e.printStackTrace();
}

SignedCallInitConfiguration initConfiguration = new SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
        .setFCMProcessingMode(FCMProcessingMode.FOREGROUND, fcmProcessingNotification)
        .build();

SignedCallAPI.getInstance().init(getApplicationContext(), initConfiguration, cleverTapAPI, signedCallInitListener);

var fcmProcessingNotification: FCMProcessingNotification? = null
try {
    fcmProcessingNotification = FCMProcessingNotification.Builder(notiTitle, notiSubtitle)
        .setLargeIcon(fcmNotificationLargeIcon)
        .setCancelCtaLabel(cancelCta)
        .build()

} catch (e: Exception) {
    e.printStackTrace()
}

val initConfiguration = SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
    .setFCMProcessingMode(FCMProcessingMode.FOREGROUND, fcmProcessingNotification)
    .build()

SignedCallAPI.getInstance().init(applicationContext, initConfiguration, cleverTapAPI, signedCallInitListener)

OutgoingCallResponse outgoingCallResponseListener = new OutgoingCallResponse() {
    @Override
    public void onSuccess() {
        //App is notified on the main thread when the call-request is accepted and being processed by the signalling channel
    }

    @Override
    public void onFailure(CallException callException) {
        //App is notified on the main thread when the call is failed
        Log.d("SignedCall: ", "error code: " + callException.getErrorCode()
               + "\n error message: " + callException.getMessage()
               + "\n error explanation: " + callException.getExplanation());

        if (callException.getErrorCode() == CallException.BadNetworkException.getErrorCode()) {
            //Handle this error here
        }
    }
};

SignedCallAPI.getInstance().call(getApplicationContext(), receiverCuid, contextOfCall, callOptions, outgoingCallResponseListener);

val outgoingCallResponseListener: OutgoingCallResponse = object : OutgoingCallResponse {
    override fun onSuccess() {
        //App is notified on the main thread when the call-request is accepted and being processed by the signalling channel
    }

    override fun onFailure(callException: CallException) {
        //App is notified on the main thread when the call is failed
        Log.d("SignedCall: ", "error code: ${callException.errorCode}" 
               + "\n error message: ${callException.message}" 
               + "\n error explanation: ${callException.explanation}")
    }
}


SignedCallAPI.getInstance().call(applicationContext, receiverCuid, contextOfCall, callOptions, outgoingCallResponseListener)

OutgoingCallResponse outgoingCallResponseListener = new OutgoingCallResponse() {
    @Override
    public void onSuccess() {
        //App is notified on the main thread when the call-request is accepted and being processed by the signalling channel
    }

    @Override
    public void onFailure(CallException callException) {
        //App is notified on the main thread when the call is failed
        Log.d("SignedCall: ", "error code: " + callException.getErrorCode()
               + "\n error message: " + callException.getMessage()
               + "\n error explanation: " + callException.getExplanation());

        if (callException.getErrorCode() == CallException.BadNetworkException.getErrorCode()) {
            //Handle this error here
        }
    }
};

SignedCallAPI.getInstance().call(getApplicationContext(), receiverCuid, contextOfCall, callOptions, requestId, outgoingCallResponseListener);

val outgoingCallResponseListener: OutgoingCallResponse = object : OutgoingCallResponse {
    override fun onSuccess() {
        //App is notified on the main thread when the call-request is accepted and being processed by the signalling channel
    }

    override fun onFailure(callException: CallException) {
        //App is notified on the main thread when the call is failed
        Log.d("SignedCall: ", "error code: ${callException.errorCode}" 
               + "\n error message: ${callException.message}" 
               + "\n error explanation: ${callException.explanation}")
    }
}


SignedCallAPI.getInstance().call(applicationContext, receiverCuid, contextOfCall, callOptions, requestId, outgoingCallResponseListener)

SignedCallInitConfiguration initConfiguration = new SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
         .overrideRequestId(<pass boolean here>)
         .build();

SignedCallAPI.getInstance().init(getApplicationContext(), initConfiguration, cleverTapAPI, signedCallInitListener)

val initConfiguration = SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
        .overrideRequestId(<pass boolean here>)
        .build()

SignedCallAPI.getInstance().init(applicationContext, initConfiguration, cleverTapAPI, signedCallInitListener)

//Creates push primer config using Half-Interstitial template
JSONObject jsonObjectConfig = CTLocalInApp.builder()
        .setInAppType(CTLocalInApp.InAppType.HALF_INTERSTITIAL)
        .setTitleText("Get Notified")
        .setMessageText("Please enable notifications on your device to use Push Notifications.")
        .followDeviceOrientation(true)
        .setPositiveBtnText("Allow")
        .setNegativeBtnText("Cancel")
        .setBackgroundColor(Constants.WHITE)
        .setBtnBorderColor(Constants.BLUE)
        .setTitleTextColor(Constants.BLUE)
        .setMessageTextColor(Constants.BLACK)
        .setBtnTextColor(Constants.WHITE)
        .setImageUrl("https://icons.iconarchive.com/icons/treetog/junior/64/camera-icon.png")
        .setBtnBackgroundColor(Constants.BLUE)
        .build();


//Creates push primer config using Alert template
JSONObject jsonObjectConfig = CTLocalInApp.builder()
        .setInAppType(CTLocalInApp.InAppType.ALERT)
        .setTitleText("Get Notified")
        .setMessageText("Enable Notification permission")
        .followDeviceOrientation(true)
        .setPositiveBtnText("Allow")
        .setNegativeBtnText("Cancel")
        .build();

//Creates push primer config using Half-Interstitial template
val jsonObjectConfig = CTLocalInApp.builder()
            .setInAppType(InAppType.HALF_INTERSTITIAL)
            .setTitleText("Get Notified")
            .setMessageText("Please enable notifications on your device to use Push Notifications.")
            .followDeviceOrientation(true)
            .setPositiveBtnText("Allow")
            .setNegativeBtnText("Cancel")
            .setBackgroundColor(Constants.WHITE)
            .setBtnBorderColor(Constants.BLUE)
            .setTitleTextColor(Constants.BLUE)
            .setMessageTextColor(Constants.BLACK)
            .setBtnTextColor(Constants.WHITE)
            .setImageUrl("https://icons.iconarchive.com/icons/treetog/junior/64/camera-icon.png")
            .setBtnBackgroundColor(Constants.BLUE)
            .build()


//Creates push primer config using Alert template
val jsonObjectConfig = CTLocalInApp.builder()
            .setInAppType(InAppType.ALERT)
            .setTitleText("Get Notified")
            .setMessageText("Enable Notification permission")
            .followDeviceOrientation(true)
            .setPositiveBtnText("Allow")
            .setNegativeBtnText("Cancel")
            .build()

SignedCallInitConfiguration initConfiguration = new SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
         .promptPushPrimer(jsonObjectConfig)
         .build();

SignedCallAPI.getInstance().init(getApplicationContext(), initConfiguration, cleverTapAPI, signedCallInitListener);

val initConfiguration = SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
        .promptPushPrimer(jsonObjectConfig)
        .build()

SignedCallAPI.getInstance().init(applicationContext, initConfiguration, cleverTapAPI, signedCallInitListener)

SignedCallInitConfiguration initConfiguration = new SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
         .setNotificationPermissionRequired(<pass boolean here>)
         .build();

SignedCallAPI.getInstance().init(getApplicationContext(), initConfiguration, cleverTapAPI, signedCallInitListener)

val initConfiguration = SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
        .setNotificationPermissionRequired(<pass boolean here>)
        .build()

SignedCallAPI.getInstance().init(applicationContext, initConfiguration, cleverTapAPI, signedCallInitListener)

boolean status = SignedCallAPI.getInstance().isInitialized(context);
Log.d(LOG_TAG, "Initialization status: " + status);

val status = SignedCallAPI.getInstance().isInitialized(context)
Log.d(LOG_TAG, "Initialization status: $status")

SignedCallAPI.getInstance().logout(getApplicationContext());

SignedCallAPI.getInstance().logout(applicationContext)

SignedCallInitConfiguration initConfiguration = new SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
         .callScreenOnSignalling(<pass boolean here>) // Set to true to display call screen only after signaling is complete
         .build();

SignedCallAPI.getInstance().init(getApplicationContext(), initConfiguration, cleverTapAPI, signedCallInitListener)

val initConfiguration = SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
        .callScreenOnSignalling(<pass boolean here>) // Set to true to display call screen only after signaling is complete
        .build()

SignedCallAPI.getInstance().init(applicationContext, initConfiguration, cleverTapAPI, signedCallInitListener)

SignedCallAPI.getInstance().setNetworkQualityCheckHandler(new SCNetworkQualityHandler() {
    @Override
    public boolean onNetworkQualityResponse(final int score) {
        Log.d(LOG_TAG, "Network quality score: " + score);

        // Return true to proceed with the call, or false to reject the call
        return true/false;
    }
});

SignedCallAPI.getInstance().setNetworkQualityCheckHandler(object : SCNetworkQualityHandler {
    override fun onNetworkQualityResponse(score: Int): Boolean {
        Log.d(LOG_TAG, "Network quality score: $score")

        // Return true to proceed with the call, or false to reject the call
        return true // or false
    }
})

SignedCallAPI.getInstance().registerVoIPCallStatusListener(new SCVoIPCallStatusListener() {
   @Override
   public void callStatus(final SCCallStatusDetails callStatusDetails) {
       //App is notified on the main thread to notify the changes in the call-state
       Log.d(LOG_TAG, "callStatus is invoked with: " + callStatusDetails.toString());

       SCCallStatusDetails.CallDirection direction = callStatusDetails.getDirection();
       VoIPCallStatus callStatus = callStatusDetails.getCallStatus();
       CallDetails callDetails = callStatusDetails.getCallDetails()
       String callId = callDetails.callId;
     	String requestId = callDetails.requestId; 
       SignallingChannel channel = callDetails.channel;
    
       if (direction.equals(CallDirection.OUTGOING)) {
           //Handle events for initiator of the call

           if (callStatus == VoIPCallStatus.CALL_IS_PLACED) {
               // When the call is successfully placed
           }  else if (callStatus == VoIPCallStatus.CALL_RINGING) {
               // When the call starts ringing on the receiver's device
           } else if (callStatus == VoIPCallStatus.CALL_CANCELLED) {
               // When the call is cancelled from the initiator's end
           } else if (callStatus == VoIPCallStatus.CALL_CANCELLED_DUE_TO_RING_TIMEOUT) {
               // When the call is call is cancelled due to a ring timeout.
               // This event is reported when the SDK fails to establish communication with the receiver, often due to an offline device or a device with low bandwidth.
           } else if (callStatus == VoIPCallStatus.CALL_DECLINED) {
               // When the call is declined from the receiver's end
           } else if (callStatus == VoIPCallStatus.CALL_MISSED) {
               // When the call is missed at the receiver's end
           } else if (callStatus == VoIPCallStatus.CALL_ANSWERED) {
               // When the call is picked up by the receiver
           } else if (callStatus == VoIPCallStatus.CALL_IN_PROGRESS) {
               // When the connection to the receiver is established
           } else if (callStatus == VoIPCallStatus.CALL_OVER) {
               // When the call has been disconnected
           }  else if (callStatus == VoIPCallStatus.CALL_OVER_DUE_TO_LOCAL_NETWORK_LOSS) {
               // When the call is disconnected for the party that experienced a network loss
           } else if (callStatus == VoIPCallStatus.CALL_OVER_DUE_TO_REMOTE_NETWORK_LOSS) {
               // When the call has been disconnected for the party that dropped due to network loss at remote end
           } else if (callStatus == VoIPCallStatus.CALL_OVER_DUE_TO_PROTOCOL_MISMATCH) {
               // When the call has been disconnected due to protocol mismatch.
           } else if (callStatus == VoIPCallStatus.CALL_OVER_DUE_TO_NETWORK_DELAY_IN_MEDIA_SETUP) {
               // When the call disconnects due to network delays that prevent media setup.
           } else if (callStatus == VoIPCallStatus.CALLEE_BUSY_ON_ANOTHER_CALL) {
               // When the receiver is busy on another call(includes both VoIP or PSTN)
           }  else if (callStatus == VoIPCallStatus.CALL_DECLINED_DUE_TO_BUSY_ON_VOIP) {
               // When the receiver is busy in a VoIP call
           } else if (callStatus == VoIPCallStatus.CALL_DECLINED_DUE_TO_BUSY_ON_PSTN) {
               // When the receiver is busy in a PSTN call
           } else if (callStatus == VoIPCallStatus.CALL_DECLINED_DUE_TO_LOGGED_OUT_CUID) {
               // When the receiver's cuid is logged out and logged in with different cuid 
           } else if (callStatus == VoIPCallStatus.CALL_DECLINED_DUE_TO_NOTIFICATIONS_DISABLED) {
               // When the receiver's Notifications Settings are disabled from application settings
           } else if (callStatus == VoIPCallStatus.CALLEE_MICROPHONE_PERMISSION_NOT_GRANTED) {
               // When the Microphone permission is denied or blocked while receiver answers the call
           } else if (callStatus == VoIPCallStatus.CALLEE_MICROPHONE_PERMISSION_BLOCKED) {
               // When the microphone permission is blocked at the receiver's end.
           } else if (callStatus == VoIPCallStatus.CALL_FAILED_DUE_TO_INTERNAL_ERROR) {
               // When the call fails after signalling. Possible reasons could include low internet connectivity, low RAM available on device, SDK fails to set up the voice channel within the time limit
             } else if(callStatus == VoIPCallStatus.CALL_OVER_DUE_TO_NETWORK_DELAY_IN_CONNECTION_SETUP) {
           	 // When the call fails due to network delay during the call setup phase when a call is answered but not yet ready for voice exchange.
           }
       } else if (direction.equals(CallDirection.INCOMING)) {
               //Handle events for receiver of the call
               // Receiver will get the same list of events as above so handle accordingly
       }
    }
});

SignedCallAPI.getInstance().registerVoIPCallStatusListener(object : SCVoIPCallStatusListener {
   override fun callStatus(callStatusDetails: SCCallStatusDetails) {
       // App is notified on the main thread to notify the changes in the call-state
       Log.d(LOG_TAG, "callStatus is invoked with: ${callStatusDetails.toString()}")

       val direction = callStatusDetails.direction
       val callStatus: VoIPCallStatus = callStatusDetails.callStatus
       val callDetails: CallDetails = callStatusDetails.callDetails
       val channel: SignallingChannel = callDetails.channel
       val callId: String = callDetails.callId;
       val requestId: String = callDetails.requestId;

       if (direction == SCCallStatusDetails.CallDirection.OUTGOING) {
           // Handle the events for initiator of the call

           when (callStatus) {
               VoIPCallStatus.CALL_IS_PLACED -> {
                   // When the call is successfully placed
               }
               VoIPCallStatus.CALL_RINGING -> {
                   // When the call starts ringing on the receiver's device
               }
               VoIPCallStatus.CALL_CANCELLED -> {
                   // When the call is cancelled from the initiator's end
               }
               VoIPCallStatus.CALL_DECLINED -> {
                   // When the call is declined from the receiver's end
               }
               VoIPCallStatus.CALL_MISSED -> {
                   // When the call is missed at the receiver's end
               }
               VoIPCallStatus.CALL_ANSWERED -> {
                   // When the call is picked up by the receiver
               }
               VoIPCallStatus.CALL_IN_PROGRESS -> {
                   // When the connection to the receiver is established
               }
               VoIPCallStatus.CALL_OVER -> {
                   // When the call has been disconnected
               }
               VoIPCallStatus.CALL_OVER_DUE_TO_LOCAL_NETWORK_LOSS -> {
                   // // When the call is disconnected for the party that experienced a network loss
               }
               VoIPCallStatus.CALL_OVER_DUE_TO_REMOTE_NETWORK_LOSS -> {
                   // When the call has been disconnected for the party that dropped due to network loss at remote end
               }
               VoIPCallStatus.CALL_OVER_DUE_TO_PROTOCOL_MISMATCH -> {
                   // When the call has been disconnected due to protocol mismatch.
               }
               VoIPCallStatus.CALL_OVER_DUE_TO_NETWORK_DELAY_IN_MEDIA_SETUP -> {
                   When the call disconnects due to network delays that prevent media setup.
               }
               VoIPCallStatus.CALLEE_BUSY_ON_ANOTHER_CALL -> {
                   // When the receiver is busy on another call
               }
               VoIPCallStatus.CALL_DECLINED_DUE_TO_LOGGED_OUT_CUID -> {
                   // When the receiver's cuid is logged out and logged in with a different cuid
               }
               VoIPCallStatus.CALL_DECLINED_DUE_TO_NOTIFICATIONS_DISABLED -> {
                   // When the receiver's Notifications Settings are disabled from application settings
               }
               VoIPCallStatus.CALLEE_MICROPHONE_PERMISSION_NOT_GRANTED -> {
                   // When the Microphone permission is denied or blocked while the receiver answers the call
               }
               VoIPCallStatus.CALLEE_MICROPHONE_PERMISSION_BLOCKED -> {
                   // When the microphone permission is blocked at the receiver's end.
               }
               VoIPCallStatus.CALL_FAILED_DUE_TO_INTERNAL_ERROR -> {
                   // When the call fails after signalling. Possible reasons could include low internet connectivity, low RAM available on device, SDK fails to set up the voice channel within the time limit
               }
               VoIPCallStatus.CALL_OVER_DUE_TO_NETWORK_DELAY_IN_CONNECTION_SETUP {
           	 // When the call fails due to network delay during the call setup phase when a call is answered but not yet ready for voice exchange.
           }
           }
       } else if (direction == SCCallStatusDetails.CallDirection.INCOMING) {
           // Handle the events for the receiver of the call
           // Receiver will get the same list of events as above so handle accordingly
         
       }
   }
})

SCCallController callController = SignedCallAPI.getInstance().getCallController();
if (callController != null) {
    SCCallState callState = callController.getCallState();
    Log.d(LOG_TAG, "call is in " + callState.name() + " state");
}

val callController: SCCallController? = SignedCallAPI.getInstance().callController
callController?.let {
    val callState: SCCallState = callController.callState
    Log.d(LOG_TAG, "call is in ${callState.name} state")
}

SCCallController callController = SignedCallAPI.getInstance().getCallController();
if (callController != null && callController.getCallState() != SCCallState.NO_CALL) {
    boolean result = callController.getBackToCall(getApplicationContext());
    Log.d(LOG_TAG, "result: " + result);
}

val callController = SignedCallAPI.getInstance().callController
callController?.let { controller ->
    if (controller.callState != SCCallState.NO_CALL) {
        val result = controller.getBackToCall(applicationContext)
        Log.d(LOG_TAG, "result: $result")
    }
}

SignedCallAPI.getInstance().disconnectSignallingSocket(getApplicationContext());

SignedCallAPI.getInstance().disconnectSignallingSocket(applicationContext);

List<MissedCallAction> missedCallActionsList = new ArrayList<>();
missedCallActionsList.add(new MissedCallAction("<Unique Identifier>", "<label on action-button>"));

val missedCallActionsList: MutableList<MissedCallAction> = ArrayList()
missedCallActionsList.add(MissedCallAction("<Unique Identifier>", "<label on action-button>"))

public class MissedCallActionsHandler implements MissedCallNotificationOpenedHandler {

    @Override
    public void onMissedCallNotificationOpened(Context context, MissedCallNotificationOpenResult result) {
        //get the the action-details from result object and handle accordingly
        Log.d(LOG_TAG, "actionId: " + result.action.actionID
                    + ", actionLabel: " + result.action.actionLabel
                    + ", context of call: " + result.callDetails.callContext
                    + ", cuid of caller: " + result.callDetails.callerCuid
                    + ", cuid of callee: " + result.callDetails.calleeCuid
                    + ", initiator's image: " + result.callDetails.initiatorImage
                    + ", receiver's image: " + result.callDetails.receiverImage
                    + ", call id: " + result.callDetails.callId
                    + ", request id " + result.callDetails.requestId
             );
    }
}

class MissedCallActionsHandler : MissedCallNotificationOpenedHandler {

    override fun onMissedCallNotificationOpened(context: Context, result: MissedCallNotificationOpenResult) {
        //get the the action-details from result object and handle accordingly
        Log.d(TAG, "actionId: " + result.action.actionID
                    + " actionLabel: " + result.action.actionLabel
                    + " context of call: " + result.callDetails.callContext
                    + " cuid of caller: " + result.callDetails.callerCuid
                    + " cuid of callee: " + result.callDetails.calleeCuid
             			  + ", call id: " + result.callDetails.callId
                    + ", request id " + result.callDetails.requestId);
    }
}

List<MissedCallAction> missedCallActionsList = new ArrayList<>();
missedCallActionsList.add(new MissedCallAction("<Unique Identifier>", "<label on action-button>"));

//gets the name of the class including its package
String missedCallHandlerPath = MissedCallActionsHandler.class.getCanonicalName();

SignedCallInitConfiguration initConfiguration = new SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
       .setMissedCallActions(missedCallActionsList, missedCallHandlerPath)
       .build();

SignedCallAPI.getInstance().init(getApplicationContext(), initConfiguration, cleverTapAPI, signedCallInitListener);

val missedCallActionsList: MutableList<MissedCallAction> = ArrayList()
missedCallActionsList.add(MissedCallAction("<Unique Identifier>", "<label on action-button>"))

//gets the name of the class including its package
val missedCallHandlerPath = MissedCallActionsHandler::class.java.canonicalName

val initConfiguration = SignedCallInitConfiguration.Builder(options, allowPersistSocketConnection)
    .setMissedCallActions(missedCallActionsList, missedCallHandlerPath)
    .build()

SignedCallAPI.getInstance().init(applicationContext, initConfiguration, cleverTapAPI, signedCallInitListener)

List<MissedCallAction> missedCallActionsList = new ArrayList<>();
missedCallActionsList.add(new MissedCallAction("<Unique Identifier>", "<label on action-button>"));

SignedCallInitConfiguration initConfiguration = new SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
       .setMissedCallActions(missedCallActionsList)
       .build();

SignedCallAPI.getInstance().init(getApplicationContext(), initConfiguration, cleverTapAPI, signedCallInitListener);

val missedCallActionsList = mutableListOf<MissedCallAction>()
missedCallActionsList.add(MissedCallAction("<Unique Identifier>", "<label on action-button>"))

val initConfiguration = SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
    .setMissedCallActions(missedCallActionsList)
    .build()

SignedCallAPI.getInstance().init(applicationContext, initConfiguration, cleverTapAPI, signedCallInitListener)

public class MissedCallNotificationHandler implements MissedCallNotificationOpenedHandler {
    
    @Override
    public void onMissedCallNotificationOpened(Context context, MissedCallNotificationOpenResult result) {
        if (SignedCallAPI.getInstance().isInitialized(context)) {
            initiateCall(context, result);
        } else {
            Log.d(LOG_TAG, "SDK is being initialized, please wait!");
            initSignedCallSDK(context, () -> initiateCall(context, result));
        }
    }

    private void initiateCall(Context context, MissedCallNotificationOpenResult result) {
        SignedCallAPI.getInstance().call(context, result.callDetails.callerCuid, result.callDetails.callContext, null, new OutgoingCallResponse() {
            @Override
            public void onSuccess() {
                Log.d(LOG_TAG, "Call successfully initiated!");
            }

            @Override
            public void onFailure(CallException callException) {
                Log.d(LOG_TAG, "Call failed: " + callException.getMessage());
            }
        });
    }

    private void initSignedCallSDK(Context context, Runnable onSuccessCallback) {
        try {
            SignedCallAPI.getInstance().init(context, initConfiguration, CleverTapAPI.getDefaultInstance(context), new SignedCallInitResponse() {
                @Override
                public void onSuccess() {
                    onSuccessCallback.run();
                }

                @Override
                public void onFailure(@NonNull InitException initException) {
                    Log.d(LOG_TAG, "Initialization failed: " + initException.getMessage());
                }
            });
        } catch (Exception e) {
            Log.e(LOG_TAG, "Exception while initializing SignedCallSDK: " + e.getLocalizedMessage());
        }
    }
}

class MissedCallNotificationHandler : MissedCallNotificationOpenedHandler {
    
    override fun onMissedCallNotificationOpened(context: Context, result: MissedCallNotificationOpenResult) {
        if (SignedCallAPI.getInstance().isInitialized(context)) {
            initiateCall(context, result)
        } else {
            Log.d(LOG_TAG, "SDK is being initialized, please wait!")
            initSignedCallSDK(context) { initiateCall(context, result) }
        }
    }

    private fun initiateCall(context: Context, result: MissedCallNotificationOpenResult) {
        SignedCallAPI.getInstance().call(
            context, result.callDetails.callerCuid, result.callDetails.callContext, null,
            object : OutgoingCallResponse {
                override fun onSuccess() {
                    Log.d(LOG_TAG, "Call successfully initiated!")
                }

                override fun onFailure(callException: CallException) {
                    Log.d(LOG_TAG, "Call failed: ${callException.message}")
                }
            }
        )
    }

    private fun initSignedCallSDK(context: Context, onSuccessCallback: () -> Unit) {
        try {
            SignedCallAPI.getInstance().init(
                context,
                initConfiguration,
                CleverTapAPI.getDefaultInstance(context),
                object : SignedCallInitResponse {
                    override fun onSuccess() {
                        onSuccessCallback()
                    }

                    override fun onFailure(initException: InitException) {
                        Log.d(LOG_TAG, "Initialization failed: ${initException.message}")
                    }
                }
            )
        } catch (e: Exception) {
            Log.e(LOG_TAG, "Exception while initializing SignedCallSDK: ${e.localizedMessage}")
        }
    }
}

boolean result = SignedCallAPI.getInstance().dismissMissedCallNotification(getApplicationContext());
Log.d(LOG_TAG, "Notification dismissal result: " + result);

val result = SignedCallAPI.getInstance().dismissMissedCallNotification(applicationContext)
Log.d(LOG_TAG, "Notification dismissal result: $result")

SignedCallInitConfiguration initConfiguration = new SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
         .setSwipeOffBehaviourInForegroundService(<pass SCSwipeOffBehaviour constant here>)
         .build();

SignedCallAPI.getInstance().init(getApplicationContext(), initConfiguration, cleverTapAPI, signedCallInitListener)

val initConfiguration = SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
        .setSwipeOffBehaviourInForegroundService(<pass SCSwipeOffBehaviour constant here>)
        .build()

SignedCallAPI.getInstance().init(applicationContext, initConfiguration, cleverTapAPI, signedCallInitListener)

SCCallController callController = SignedCallAPI.getInstance().getCallController();
if (callController != null) {
    callController.endCall(); 
}

SignedCallAPI.getInstance().callController?.endCall()

SignedCallScreenBranding callScreenBranding = new SignedCallScreenBranding(bgColor, fontColor, logoUrl, buttonTheme, cancelCountdownColor);
callScreenBranding.setShowPoweredBySignedCall(<true/false>); //set false to hide the label from VoIP call screens. Default value is true. 

SignedCallInitConfiguration initConfiguration = new SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)  
      .overrideDefaultBranding(callScreenBranding)
      .build();

SignedCallAPI.getInstance().init(getApplicationContext(), initConfiguration, cleverTapAPI, signedCallInitListener);

val callScreenBranding = SignedCallScreenBranding(bgColor, fontColor, logoUrl, buttonTheme)

val initConfiguration = SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
    .overrideDefaultBranding(callScreenBranding)
    .build()

SignedCallAPI.getInstance().init(applicationContext, initConfiguration, cleverTapAPI, signedCallInitListener)

SignedCallScreenBranding callScreenBranding = new SignedCallScreenBranding.Builder()
        .setBgColor(bgColor)
        .setFontColor(fontColor)
        .setLogoUrl(logoUrl)
        .setButtonTheme(buttonTheme)
        .setCancelCountdownColor(cancelCountdownColor)
        .setShowPoweredBySignedCall(<true/false>)
        .build();

SignedCallInitConfiguration initConfiguration = new SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)  
      .overrideDefaultBranding(callScreenBranding)
      .build();

SignedCallAPI.getInstance().init(getApplicationContext(), initConfiguration, cleverTapAPI, signedCallInitListener);

val callScreenBranding = SignedCallScreenBranding.Builder()
    .setBgColor(bgColor)
    .setFontColor(fontColor)
    .setLogoUrl(logoUrl)
    .setButtonTheme(buttonTheme)
    .setCancelCountdownColor(cancelCountdownColor)
    .setShowPoweredBySignedCall(<true/false>)
    .build()

val initConfiguration = SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
    .overrideDefaultBranding(callScreenBranding)
    .build()

SignedCallAPI.getInstance().init(applicationContext, initConfiguration, cleverTapAPI, signedCallInitListener)

SignedCallAPI.setDebugLevel(SignedCallAPI.LogLevel.INFO);    //Default Log level

SignedCallAPI.setDebugLevel(SignedCallAPI.LogLevel.DEBUG);   //Set Log level to DEBUG log warnings or other important messages

SignedCallAPI.setDebugLevel(SignedCallAPI.LogLevel.VERBOSE); //Set Log level to VERBOSE

SignedCallAPI.setDebugLevel(SignedCallAPI.LogLevel.OFF);     //Switch off the logs for Production environment

SignedCallAPI.setDebugLevel(SignedCallAPI.LogLevel.INFO)    //Default Log level

SignedCallAPI.setDebugLevel(SignedCallAPI.LogLevel.DEBUG)   //Set Log level to DEBUG log warnings or other important messages

SignedCallAPI.setDebugLevel(SignedCallAPI.LogLevel.VERBOSE) //Set Log level to VERBOSE

SignedCallAPI.setDebugLevel(SignedCallAPI.LogLevel.OFF)     //Switch off the logs for Production environment