indigitall SDK for push clicking here

External Apps

You can choose several options to send your notifications:

*** External Apps**

External Apps on devices which you have installed or have not installed:

*** Frequency of use**

Sending a notification depending on the last time the user has visited your app/website.

*** Devices type:**
You can send your messages by devices type (mobile phone, tablet and desktop) and regarding used browsers (Safari, Opera, Edge, Firefox and Chrome).

Retargeting

Your app can send information to indigitall's servers to identify the actions and events that happen in it. This allows you to automate retargeting actions.

To register these events you have to call the sendCustomEvent method, passing a descriptive ID as a parameter (you can invent the one you like best) and set data you need.

Indigitall.sendCustomEvent(context, "YOUR_EVENT_ID", eventId: "eventID_optional", eventAt : "eventAt_optional", JSONObject("YOUR_CUSTOM_DATA"),object: EventCallback(context){
    override fun onSuccess() {
        // Do something in success function
    }
    override fun onError(@NonNull ErrorModel errorModel) {
        //SHOW ERROR
    }
});

Topics

Our SDK allows you to classify users into different customizable groups. This is very useful for:

Implement a preferences screen so that the user can choose the topics for which they want to receive notifications.
Label according to the navigation or actions that the user performs.
Segment communications according to whether the user has identified or is anonymous.
Segment based on language, culture, customer category, or based on any other criteria you need.

Remember that you must first define the groups you want to work with in the indigitall console (Tools> Topics).

List groups

Use the topicsList method to get the list of groups that are configured in your indigitall project. The callback of this method receives as a parameter an array of Topics, which contains the information of all the available groups, as well as a flag that indicates whether the user is included in any of them.

Indigitall.topicsList(context, new TopicsCallback() {
    @Override
    public void onSuccess(Topic[] topics) {
        //DO SOMETHING
    }
    @Override
    public void onFail(ErrorModel errorModel) {}
});

Manage subscription

To manage the device subscription to one or more groups, there are two methods: topicsSubscribe and topicsUnsubscribe.

Optionally, both receive a TopicsCallback object as the third parameter, which will return the list of all Topic in the project.

//topics is typeof Topic[] or typeof string[]
Indigitall.topicsSubscribe(context, topics, new TopicsCallback() {
    @Override
    public void onSuccess(Topic[] topics) {}
    @Override
    public void onFail(ErrorModel errorModel) {}
});

//topics is typeof Topic[] or typeof string[]
Indigitall.topicsUnsubscribe(context, topics, new TopicsCallback() {
    @Override
    public void onSuccess(Topic[] topics) {}
    @Override
    public void onFail(ErrorModel errorModel) {}
});

Using Topics with modular integrations

The methods shown above are available through the main Indigitall interface, which internally delegates the functionality to the corresponding modules (IndigitallPush and IndigitallInApp).

If your integration uses the full SDK, you should continue using:

Indigitall.topicsList(...)
Indigitall.topicsSubscribe(...)
Indigitall.topicsUnsubscribe(...)

However, in modular integrations where only specific components of the SDK are included, you must call the API from the module that actually manages push subscriptions.

Push-only or InApp-only integrations

Topic management (list, subscribe and unsubscribe) is handled by the Push module.

Therefore:

If you are not using the core Indigitall wrapper
And you only integrated IndigitallPush
Or you are working directly with the push module from an InApp-only setup

you must use the IndigitallPush class instead of Indigitall.

IndigitallPush.topicsList(...)
IndigitallPush.topicsSubscribe(...)
IndigitallPush.topicsUnsubscribe(...)

Firebase Utils

If you have custom Firebase classes, you may need to disable the following SDK services, defined in the manifest.xml.

<!-- <service
    android:name="com.indigitall.android.services.FirebaseMessagingService">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT"/>
    </intent-filter>
</service>
    <service
    android:name="com.indigitall.android.services.FirebaseInstanceIdService">
    <intent-filter>
        <action android:name="com.google.firebase.INSTANCE_ID_EVENT"/>
    </intent-filter>
</service> -->

If this is your case, you must add this code to ensure that notifications sent from indigitall are received and displayed.

In the service associated with the action com.google.firebase.iid.FirebaseInstanceIdService add this line to register the push token.

@Override
public void onTokenRefresh() {
    FirebaseUtils.setPushToken(context);
}

In the service associated with the com.google.firebase.messaging.FirebaseMessagingService action, if the notification comes from indigitall , the following lines of code will cause it to be painted.

//Google
@Override
public void onMessageReceived(RemoteMessage remoteMessage) {
    if(remoteMessage.getData() != null && !FirebaseUtils.pushNotificationIndigitall(remoteMessage, context)){
        //Your Code
    }
}

//Huawei
 override fun onMessageReceived(newRemoteMessage: RemoteMessage?) {
        if(remoteMessage.getData() != null && !HMSUtils.pushNotificationIndigitall(remoteMessage, context)){
        //Your Code
    }
 }

Collection of push data

In the event that you would like to obtain the push object of type json to carry out checks or actions that your application requires, we leave you this code that will help to obtain it:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (getIntent() != null && getIntent().getExtras() != null){
        Bundle extras = getIntent().getExtras();
        if( extras != null && extras.containsKey(Push.EXTRA_PUSH)) {
            Push push = new Push(extras.getString(Push.EXTRA_PUSH));
        }
    }
}

In the case of encrypted push, the Push object must be passed the context as an additional parameter:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (getIntent() != null && getIntent().getExtras() != null){
        Bundle extras = getIntent().getExtras();
        if( extras != null && extras.containsKey(Push.EXTRA_PUSH)) {
            Push push = new Push(context,extras.getString(Push.EXTRA_PUSH));
        }
    }
}

Register statistics if the Push action is involved

If you decide to treat the Push action independently without going through our SDK, the intent of the action is collected in your activity where the ServiceUtils.RegisterStatistics method should be called. For this case, you can, for example, create a class that extends from our PushNotification to generate the intent with the following extras:

public class MyPushNotification extends PushNotification {
    Push push;
    Context context;

    public MyPushNotification(Push push) {
        super(push);
        this.push = push;
    }

    @Override
    public void showNotification(Context context) {
        this.context = context;
        super.showNotification(context);
    }

    protected PendingIntent getIntent(PushAction action, int clickedButton) {      
        Intent intent = action.getIntent(context);
        Intent indigitallIntent = new Intent(context, YOUR_ACTIVITY.class);
        indigitallIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        indigitallIntent.putExtra(StatisticService.EXTRA_APP_KEY, PreferenceUtils.getAppKey(context));
        indigitallIntent.putExtra(StatisticService.EXTRA_PUSH_ID, push.getId());
        indigitallIntent.putExtra(StatisticService.EXTRA_CLICKED_BUTTON, clickedButton);
        indigitallIntent.putExtra(StatisticService.EXTRA_INTENT_ACTION, intent);
        indigitallIntent.putExtra(Push.EXTRA_PUSH, push.toString());
        if (action.getTopics() != null && action.getTopics().length>0){
            indigitallIntent.putExtra(StatisticService.EXTRA_ACTION_TOPICS, action.topicsToString());
        }
        TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);
        stackBuilder.addNextIntentWithParentStack(indigitallIntent);

        return stackBuilder.getPendingIntent((push.getId()*10) + clickedButton, PendingIntent.FLAG_UPDATE_CURRENT);
    }
}

Once the push has been collected as explained in the previous section, the following method must be called to register statistics:

ServiceUtils.registerStatistics(context,indigitallIntent);

Custom Push Notification Sounds

By default, push notifications use the system’s default sound. You can customize this behavior by assigning a specific audio file to a notification channel.

When to Consider a Custom Sound

Urgent alerts that require immediate attention.
Differentiating between notification categories (e.g., system vs. promotional).
Reinforcing a branded experience.

⚠️
Custom sounds can sometimes feel intrusive or disruptive for users, especially if they are loud, long, or significantly different from system defaults. In many cases, sticking to the standard system sound provides a more consistent and user-friendly experience.

Adding a Custom Sound File

To use a custom sound:

Place your audio file (e.g., alert.mp3) inside the res/raw/ folder of your Android project.
1. Example path: app/src/main/res/raw/alert.mp3
File names must be lowercase and should not contain spaces or special characters.

Implementing in Code

When creating a NotificationChannel (required for Android 8.0 / API level 26 and above), you can assign your custom sound to that channel:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val notificationManager =
            getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

        val channel = NotificationChannel(
            "default",            // Channel ID
            "CHANNEL_NAME",       // Channel Name (visible to the user)
            NotificationManager.IMPORTANCE_HIGH
        )

        val soundAttributes = AudioAttributes.Builder()
            .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
            .setUsage(AudioAttributes.USAGE_NOTIFICATION)
            .build()

        channel.setSound(
            Uri.parse(
                ContentResolver.SCHEME_ANDROID_RESOURCE + "://" + packageName + "/" + R.raw.alert
            ),
            soundAttributes
        )

        notificationManager.createNotificationChannel(channel)
    }
}

Important Notes

Custom sounds are tied to the notification channel. Once a channel is created, its configuration (including sound) cannot be changed. If you need to modify the sound, you must create a new channel with a different ID.
The sound file must be short and optimized for notifications (avoid large audio files).
For devices running below Android 8.0 (Oreo), custom sounds can still be used, but the implementation differs (no NotificationChannel required).

Custom Notification Sound

By default, the Indigitall SDK delivers push notifications using the Android notification channel named default.

However, if you need a custom sound or any other custom channel configuration, you must create your own notification channel and inform the SDK about it.

Create a Custom Notification Channel

You can define a new channel with a custom ID, name, and sound.
For example, let’s create one called test_channel_id with the name test_channel_name and a custom sound resource:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {  
    val channelId = "test_channel_id"  
    val channelName = "test_channel_name"


    // Custom sound resource located in res/raw/custom_sound.mp3
    val soundUri = Uri.parse("${ContentResolver.SCHEME_ANDROID_RESOURCE}://${context.packageName}/raw/custom_sound")

    val audioAttributes = AudioAttributes.Builder()
        .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
        .setUsage(AudioAttributes.USAGE_NOTIFICATION)
        .build()

    val channel = NotificationChannel(
        channelId,
        channelName,
        NotificationManager.IMPORTANCE_HIGH
    ).apply {
        setSound(soundUri, audioAttributes)
        description = "Channel for testing custom sound notifications"
    }

    val notificationManager =
        context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
    notificationManager.createNotificationChannel(channel)
}

⚠️ Make sure the sound file exists in your project at res/raw/custom_sound.mp3.

Provide the Channel to the SDK

When initializing the Indigitall SDK, tell it to use the custom channel by passing a CustomNotificationChannel object:

val config = Configuration.Builder(app!!.appKey, BuildConfig.SENDER_ID)
                    
                    .setCustomNotificationChannel(customChannel = CustomNotificationChannel(
                        "test_channel_id",
                        "test_channel_name"
                    ))
                    .build()


Indigitall.init(this, config, object : InitCallBack(this) {

How it works

The SDK will now use the test_channel_id channel instead of the default one.
Any notification sent to this app will play the custom sound you configured.
You can define multiple channels, but you must ensure the channel IDs used in your push payloads match the ones you create in code.