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)
         .setInitMode(SCInitMode.FULL_FEATURE_MODE | SCInitMode.M2P_FEATURE_MODE)
         .build();

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

val initConfiguration = SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
        .setInitMode(SCInitMode.CALL_MODE | SCInitMode.CAMPAIGN_MODE)
        .build()

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

M2PNotificationClickListener m2pNotificationClickListener = (context, m2PCallOptions) -> {
     Log.d(LOG_TAG, "M2P Notification is Clicked! " + m2PCallOptions);
 };

M2PCancelCtaClickListener m2pCancelCtaClickListener = (context, m2PCallOptions) -> {
     Log.d(LOG_TAG, "M2P Cancel CTA is Clicked!" + m2PCallOptions);
};

M2PConfiguration m2pConfiguration;
try {
   M2PNotification m2pNotification = new M2PNotification(title, subtitle);
   m2pNotification.setLargeIcon(largeIcon);
   m2pNotification.setCancelCtaLabel(cancelCta);
   m2pNotification.registerClickListener(m2pNotificationClickListener);
   m2pNotification.registerCancelCtaClickListener(m2pCancelCtaClickListener);
   m2pConfiguration = new M2PConfiguration.Builder(m2pNotification)
            build();
} catch (Exception e) {
   e.printStackTrace();
}

SignedCallInitConfiguration initConfiguration = new SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
         .setM2PConfiguration(m2pConfiguration)
         .build();

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

val m2pNotificationClickListener: M2PNotificationClickListener = M2PNotificationClickListener { context, m2PCallOptions ->
    Log.d(LOG_TAG, "M2P Notification is Clicked! $m2PCallOptions")
}

val m2pCancelCtaClickListener: M2PCancelCtaClickListener = M2PCancelCtaClickListener { context, m2PCallOptions ->
    Log.d(LOG_TAG, "M2P Cancel CTA is Clicked! $m2PCallOptions")
}

val m2pConfiguration: M2PConfiguration
try {
    val m2pNotification = M2PNotification(m2pTitle, m2pSubtitle)
    m2pNotification.largeIcon = m2pLargeIcon
    m2pNotification.cancelCtaLabel = cancelCta
    m2pNotification.registerClickListener(m2pNotificationClickListener)
    m2pNotification.registerCancelCtaClickListener(m2pCancelCtaClickListener)
    m2pConfiguration = M2PConfiguration.Builder(m2pNotification)
            .build()
} catch (e: Exception) {
    e.printStackTrace()
}

val initConfiguration = SignedCallInitConfiguration.Builder(initOptions, allowPersistSocketConnection)
         .enableM2PFeature(m2pConfiguration)
         .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)

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)

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

SignedCallAPI.getInstance().logout(applicationContext)

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
        }
    }
   
   // IMPORTANT:
   // Following callback method is no longer supported starting from v0.0.5.
   // Please use the new public API `registerVoIPCallStatusListener(SCVoIPCallStatusListener callStatusListener)`.
    @Override
    public void callStatus(VoIPCallStatus callStatus) {
        //App is notified on the main thread to notify the changes in the call-state
        if (callStatus == VoIPCallStatus.CALL_CANCELLED) {
            //when the call is cancelled from the initiator's end
        } 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.CALLEE_BUSY_ON_ANOTHER_CALL) {
            //when the receiver is busy on another call
        }
    }
};

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

val outgoingCallResponseListener: OutgoingCallResponse = object : OutgoingCallResponse {
    override fun callStatus(callStatus: VoIPCallStatus) {
        //App is notified on the main thread to notify the changes in the call-state
        if (callStatus == VoIPCallStatus.CALL_CANCELLED) {
            //when the call is cancelled from the initiator's end
        } 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.CALLEE_BUSY_ON_ANOTHER_CALL) {
            //when the receiver is busy on another call
        }
    }

    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
        }
}
  
JSONObject customKeys = new JSONObject();
try {
   customKeys.put("key1", "value1");
   customKeys.put("key2", "value2");
} catch (JSONException e) {
  //no-op
}
  
P2PCallOptions callOptions = new P2PCallOptions.Builder(receiverCuid, callContext)
        .setCustomMetaData(new SCCustomMetaData(
                "<URL that displays the receiver's image to the initiator of the call>",
                "<URL that displays the initiator's image to the receiver of the call>",
              customKeys))
        .build();

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

val outgoingCallResponseListener = 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}")

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

val customKeys = JSONObject()
try {
    customKeys.put("key1", "value1")
    customKeys.put("key2", "value2")
} catch (e: JSONException) {
    // no-op
}

val callOptions = P2PCallOptions.Builder(receiverCuid, callContext)
        .setCustomMetaData(SCCustomMetaData(
                "<URL that displays the receiver's image to the initiator of the call>",
                "<URL that displays the initiator's image to the receiver of the call>",
                customKeys))
        .build()

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

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)
    }
}

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();

        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_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.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 (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

        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_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.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
                }
            }
        } 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
           
        }
    }
})

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());

        CallType callType = callStatusDetails.getCallType();
        VoIPCallStatus callStatus = callStatusDetails.getCallStatus();
        SCCallOptions callOptions = callStatusDetails.getCallOptions();
  
         if (CallType.M2P.equals(callType)) {
            M2PCallOptions m2PCallOptions = (M2PCallOptions) callOptions;
            if (callStatus == VoIPCallStatus.DTMF_INPUT_RECEIVED) {
                // When a DTMF input is received from M2P keypad screen
                DTMFInput dtmfInput = m2PCallOptions.getDTMFInput();
                if (dtmfInput != null) {
                    Toast.makeText(this, dtmfInput.getInputKey() + " is pressed!", Toast.LENGTH_SHORT).show();
                }
            } else if (callStatus == VoIPCallStatus.CALL_IS_PLACED) {
                // When the call is successfully placed
            } 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
                List<DTMFInput> dtmfInputList = m2PCallOptions.getDtmfInputList();
                if (dtmfInputList != null) {
                    Toast.makeText(this, "list of DTMF inputs: " + dtmfInputList.size(), Toast.LENGTH_SHORT).show();
                }
            } else if (callStatus == VoIPCallStatus.CALL_CANCELLED_DUE_TO_CAMPAIGN_NOTIFICATION_CANCELLED) {
                // When the M2P call is cancelled by clicking on cancel CTA from campaign's notification
            } 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_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 (CallType.P2P.equals(callType)) {
            //Handle events for P2P calls
            P2PCallOptions p2PCallOptions = (P2PCallOptions) callOptions;
            Log.d(LOG_TAG, "P2PDetails: " + p2PCallOptions.toString());  
           
            if (callStatus == VoIPCallStatus.CALL_IS_PLACED) {
                // When the call is successfully placed
            } 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.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_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
            }
        }
     }
});

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 callType: CallType = callStatusDetails.callType
        val callStatus: VoIPCallStatus = callStatusDetails.callStatus
        val callOptions: SCCallOptions = callStatusDetails.callOptions

        if (callType == CallType.M2P) {
            val m2PCallOptions = callOptions as M2PCallOptions
            when (callStatus) {
                VoIPCallStatus.DTMF_INPUT_RECEIVED -> {
                    // When a DTMF input is received from M2P keypad screen
                    val dtmfInput: DTMFInput? = m2PCallOptions.dtmfInput
                    dtmfInput?.let {
                        Toast.makeText(this, "${it.inputKey} is pressed!", Toast.LENGTH_SHORT).show()
                    }
                }
                VoIPCallStatus.CALL_IS_PLACED -> {
                    // When the call is successfully placed
                }
                VoIPCallStatus.CALL_CANCELLED -> {
                    // When the call is cancelled from the initiator's end
                }
                VoIPCallStatus.CALL_CANCELLED_DUE_TO_RING_TIMEOUT -> {
                    // When the 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.
                }
                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
                    val dtmfInputList: List<DTMFInput>? = m2PCallOptions.dtmfInputList
                    dtmfInputList?.let {
                        Toast.makeText(this, "list of DTMF inputs: ${it.size}", Toast.LENGTH_SHORT).show()
                    }
                }
                VoIPCallStatus.CALL_CANCELLED_DUE_TO_CAMPAIGN_NOTIFICATION_CANCELLED -> {
                    // When the M2P call is cancelled by clicking on cancel CTA from campaign's notification
                }
                VoIPCallStatus.CALLEE_BUSY_ON_ANOTHER_CALL -> {
                    // When the receiver is busy on another call (includes both VoIP or PSTN)
                }
                VoIPCallStatus.CALL_DECLINED_DUE_TO_LOGGED_OUT_CUID -> {
                    // When the receiver's CUID is logged out and logged in with 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 receiver answers the call
                }
            }
        } else if (callType == CallType.P2P) {
            // Handle events for P2P calls
            val p2PCallOptions = callOptions as P2PCallOptions
            Log.d(LOG_TAG, "P2PDetails: ${p2PCallOptions.toString()}")
            
            when (callStatus) {
                VoIPCallStatus.CALL_IS_PLACED -> {
                    // When the call is successfully placed
                }
                VoIPCallStatus.CALL_CANCELLED -> {
                    // When the call is cancelled from the initiator's end
                }
                VoIPCallStatus.CALL_CANCELLED_DUE_TO_RING_TIMEOUT -> {
                    // When the 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.
                }
                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_CANCELLED_DUE_TO_CAMPAIGN_NOTIFICATION_CANCELLED -> {
                    // When the M2P call is cancelled by clicking on cancel CTA from campaign's notification
                }
                VoIPCallStatus.CALLEE_BUSY_ON_ANOTHER_CALL -> {
                    // When the receiver is busy on another call (includes both VoIP or PSTN)
                }
                VoIPCallStatus.CALL_DECLINED_DUE_TO_LOGGED_OUT_CUID -> {
                    // When the receiver's CUID is logged out and logged in with 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 receiver answers the call
                }
            }
        }
    }
})

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);
    }
}

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);
    }
}

public class MissedCallActionsHandler implements MissedCallNotificationOpenedHandler {

    @Override
    public void onMissedCallNotificationOpened(Context context, MissedCallNotificationOpenResult result) {
        CallType callType = result.getCallType();
        SCCallOptions callOptions = result.getCallOptions();

        if (CallType.P2P.equals(callType)) {
            P2PCallOptions p2PCallOptions = (P2PCallOptions) callOptions;
            Log.d(LOG_TAG, "actionID: " + result.getAction().getActionID()
                    + ", actionLabel: " + result.getAction().getActionLabel()
                    + ", context of call: " + p2PCallOptions.getCallContext()
                    + ", initiator's cuid: " + p2PCallOptions.getInitiatorCuid()
                    + ", receiver's cuid: " + p2PCallOptions.getReceiverCuid()
                    + ", customMetaData: " + (p2PCallOptions.getCustomMetaData() != null
                        ? p2PCallOptions.getCustomMetaData().toJson() : null));
        } else if (CallType.M2P.equals(callType)) {
            M2PCallOptions m2PCallOptions = (M2PCallOptions) callOptions;
            Log.d(LOG_TAG, "actionID: " + result.getAction().getActionID()
                    + ", actionLabel: " + result.getAction().getActionLabel()
                    + ", campaignLabelList: " + m2PCallOptions.getCampaignLabelList()
                    + ", context of call: " + m2PCallOptions.getCallContext());
        }
    }
}

class MissedCallActionsHandler : MissedCallNotificationOpenedHandler {

    override fun onMissedCallNotificationOpened(context: Context, result: MissedCallNotificationOpenResult) {
        val callType = result.callType
        val callOptions = result.callOptions

        if (callType == CallType.P2P) {
            val p2PCallOptions = callOptions as P2PCallOptions
            Log.d(LOG_TAG, "actionID: ${result.action.actionID}," +
                    " actionLabel: ${result.action.actionLabel}," +
                    " context of call: ${p2PCallOptions.callContext}," +
                    " initiator's cuid: ${p2PCallOptions.initiatorCuid}," +
                    " receiver's cuid: ${p2PCallOptions.receiverCuid}," +
                    " customMetaData: ${p2PCallOptions.customMetaData?.toJson()}")
        } else if (callType == CallType.M2P) {
            val m2PCallOptions = callOptions as M2PCallOptions
            Log.d(LOG_TAG, "actionID: ${result.action.actionID}," +
                    " actionLabel: ${result.action.actionLabel}," +
                    " campaignLabelList: ${m2PCallOptions.campaignLabelList}," +
                    " context of call: ${m2PCallOptions.callContext}")
        }
    }
}

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)

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);
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)

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