Connecting notifications on client🔗

To integrate notifications, you need to make a few simple steps:

Receiving notifications🔗

Step 1. Import the notification module and add permissions🔗

• Add the SDK to the project:

{
    "dependencies": {
        ...
    },
    "scopedRegistries": [
            {
                "name": "MRGS",
                "url": "https://mrgs-nexus.my.games/repository/mrgs-uninty-plugins/",
                "scopes": [
                    "games.my.mrgs"
                ]
            }
    ]
}

• To connect server notifications on iOS, make sure that certificates for Developer and Release builds of your application are added in the admin panel of your application on the MRGS website.
• To connect server notifications on Android, make sure that the key for sending notifications is registered in the admin panel of your application on the MRGS website.
• For Android, follow the documentation on connecting Firebase to your project, the resulting google-services.json file must be in the root of the assembled Android application.
• For Huawei/AppTouch Store, follow the documentation on connecting Huawei Push Kit to your project, the resulting agconnect-services.json file must be in the root of the assembled Android application.
• For iOS, if you want to support push notifications, then you need to add the necessary permissions to work with them in the project settings in Xcode:

    public class PostBuildProcessSample
    {
        [PostProcessBuild]
        public static void PostProcessBuild(BuildTarget target, string path)
        {
            if (target == BuildTarget.iOS)
            {
#if UNITY_IOS
                string projPath = PBXProject.GetPBXProjectPath(path);
                PBXProject proj = new PBXProject();
                proj.ReadFromString(File.ReadAllText(projPath));

#if UNITY_2019_3_OR_NEWER
                string projectTarget = proj.GetUnityMainTargetGuid();
#else
                string targetName = PBXProject.GetUnityTargetName();
                string projectTarget = proj.TargetGuidByName(targetName);
#endif
                //Adding capabilities
#if UNITY_2019_3_OR_NEWER
                ProjectCapabilityManager projectManager = new ProjectCapabilityManager(projPath, "ios.entitlements", targetGuid: projectTarget);
#else
                ProjectCapabilityManager projectManager = new ProjectCapabilityManager(projPath, "ios.entitlements", targetName);
#endif
                projectManager.AddPushNotifications(development: true);
                projectManager.AddBackgroundModes(options: BackgroundModesOptions.RemoteNotifications);
                projectManager.WriteToFile();
#endif

            }
        }
    }

if ('**APPLICATIONID**' == Your application package name)
{
    copy {
        from "./src/main/assets/"
        into "./"
        include 'google-services.json'
    }

    apply plugin: 'com.google.gms.google-services'
}

if ('**APPLICATIONID**' == Your application package name)
{
    copy {
        from "./src/main/assets/"
        into "./"
        include 'agconnect-services.json'
    }

    apply plugin: 'com.huawei.agconnect'
}

<key>NSLocationWhenInUseUsageDescription</key>
<string>We want to send you notifications when you approach your base!</string>

Step 2. Parameter settings🔗

On launch of the MRGS SDK you need to add installation of the notification settings:

using MRGS;

public class MasterController : MonoBehaviour
{
    void Awake()
    {
        MRGServiceParams serviceParams = new MRGServiceParams(MRGS_APP_ID, CLIENT_SECRET);

        serviceParams.IOSExtraOptions.AllowPushNotifications = true; // Enabling notifications
        serviceParams.IOSExtraOptions.ShouldResetBadge = true; // Reset the number on the icon when opening from background

        // Further setup and initialization of MRGS
        // ...
    }
}

The ShouldResetBadge flag must be set to true if you want MRGS to work with the number on the application icon - when the application starts the number on the icon will be reset.

Further, after the SDK launch, MRGS will do everything itself, namely:

1. Request permission to send notifications.
2. If the user agrees, we will send deviceToken to the MRGS server to send Push notifications.

// MRGService settings
MRGServiceParams serviceParams = new MRGServiceParams(MRGS_APP_ID, CLIENT_SECRET);
// ...
// Exclusion of badges on the icon and sound, only banners will remain
MRGSNotificationCenter.ExcludePermissionsForNotificationsAuthorizationRequest(MRGSNotificationAuthorizationOptionType.Badge | MRGSNotificationAuthorizationOptionType.Sound);

// Further configuration and initialization of MRGS
// ...

Step 3. Delegate setup🔗

Step 3.1. Notification receiving delegate🔗

To receive a callback about a notification arrival, or about a click on it, you must install and implement a delegate of the IMRGSNotificationCenterDelegate type.

// Setting a generic delegate without splitting by the type of notifications received (local or push)
// 'this' conforms to 'IMRGSNotificationCenterDelegate' protocol
MRGSNotificationCenter.Instance.Delegate = this;

When a notification is received or it is clicked on, the delegate method will be called:

void OnNotificationReceive(MRGSNotification notification){ //Receiving
}
void OnNotificationClick(MRGSNotification notification){   //Clicking
}

You can find out the type of notification received by using the notification.Trigger.TriggerType parameter, which will be discussed below.

// Setting a separated delegate with a breakdown by the type of notifications received (separately local, separately push)
// 'this' conforms to 'IMRGSNotificationCenterRemoteDelegate' protocol
MRGSNotificationCenter.Instance.RemoteDelegate = this;

// 'this' conforms to 'IMRGSNotificationCenterLocalDelegate' protocol
MRGSNotificationCenter.Instance.LocalDelegate = this;

void On(Local|Remote)NotificationReceive(MRGSNotification notification) //Receiving
void On(Local|Remote)NotificationClick(MRGSNotification notification) //Clicking

Step 3.2. Notification permission delegate (for iOS)🔗

If you want to receive a callback at the moment when the user clicks the "Allow notifications" button with information about their decision, you can use the IMRGSNotificationCenterAuthorizationDelegate delegate. The delegate must be set as soon as possible.

Example:

// Setting delegate
// 'this' conforms to 'IMRGSNotificationCenterAuthorizationDelegate' protocol
MRGSNotificationCenter.Instance.AuthorizationDelegate = this;

// Receiving callback
public void OnRequestUserNotificationsAuthorizationWithResult(bool granted)
{
    string isGranted = granted ? "granted" : "not granted";
    Debug.Log("Received callback that user has " + isGranted + " access to notifications" );
}

Working with notifications🔗

The main object that describes the notification is the MRGSNotification. It is necessary for sending local notifications, and also describes the notification received (both Push and local).

Step 1. Creation🔗

To create a notification object, use the following method:

MRGSNotification.Create(identifier: 777); //Unique notification identifier

Then you need to configure the notification:

notification.Title = "Hello"; //Notification header
notification.Subtitle = "Sub_Hello"; //Notification subtitle. (Only on iOS)
notification.Body = "From Unity"; //The body of the notification. (The main text of the notification.)
notification.Sound = "soundFile.caf"; //Custom sound

//Additional information added to the notification. (payload for Push notifications is located in this field)
notification.DeveloperPayload = new Dictionary<string,object>();
notification.DeveloperPayload["someInfoKey"] = "someImportantInfo";

//Setting up the trigger rule
//In this case, the notification will be displayed after 7 seconds.
notification.Trigger = MRGSNotificationTrigger.TriggerWithTimeInterval(timeInterval: 7, repeats: false);

We also provide the ability to "quickly" create notification objects - you can use the quick notification creation using the following methods:

MRGSNotification.Create(title: "_", body: "_", identifier: 1123, timeInterval: 7); //will trigger in 7 seconds
MRGSNotification.Create(title: "_", body: "_", identifier: 1123, trigger: TRIGGER); //where TRIGGER is an object of the MRGSNotificationTrigger class
MRGSNotification.Create(title: "_", body: "_", identifier: 1123, date: DATE); //where DATE is an object of DateTime class in UTC format

Step 2. Trigger rules🔗

MRGSNotificationTrigger is a class for setting or defining rules for triggering notifications. There are four types:

1. TimeInterval - Trigger with a set time interval (Will trigger after X seconds).
2. DateComponents - Trigger with set date rules (For example, 15^th day of the month, 15 hours 17 minutes (Then the trigger will fire on the next 15 hours 15 minutes local time.). (using Local time!)
3. Location - Trigger based on the user's location (only for iOS).
4. Remote - Trigger indicating that notification is the Push notification.

To create the selected trigger (except for Remote - it is created by MRGS upon receiving the notification) use the following method:

//Creating the kMRGSTimeIntervalTrigger trigger
MRGSNotificationTrigger* trigger = MRGSNotificationTrigger.TriggerWithTimeInterval(timeInterval: 70, repeats: false) //Will trigger after 70 seconds.

//Creating the kMRGSDateComponentsTrigger trigger
MRGSNotificationTrigger.MRGSDateComponents components = new MRGSNotificationTrigger.MRGSDateComponents();
components.minute = 30;
components.hour = 5;
components.day = 15;
MRGSNotificationTrigger* trigger = MRGSNotificationTrigger.TriggerWithDateComponents(dateComponents: components, repeats: false); //Will trigger on the nearest 15th of the month at 5 hours 30 minutes. (using Local time!)

//Creating the kMRGSLocationTrigger trigger
MRGSNotificationTrigger.MRGSLocation location = MRGSNotificationTrigger.MRGSLocation.Create(centerX: 1.32f, centerY: 1.325f, radius: 100.345f);
MRGSNotificationTrigger locationTrigger = MRGSNotificationTrigger.TriggerWithLocation(location: location, notifyOnEntry: true, notifyOnExit: true, repeats: false); //Will trigger on entering and leaving the specified area.

The repeats: parameter, when created, indicates whether the trigger will be repeated (for example, will it repeat every 70 seconds, every day at 13.00, or work each time user enters the specified location)). (only for iOS)

The trigger in the arrived notification will contain the triggerType field, from which you can determine whether the notification is local or remote, and it will also contain the corresponding fields with data for each type of trigger (interval, or date components, or location).

You can also use the quick creation of a trigger for a specific date in DateTime or long (for unixTime) format:

MRGSNotificationTrigger* trigger = MRGSNotificationTrigger.TriggerWithDate(DateTime.UtcNow.AddDays(5)); //In UTC
MRGSNotificationTrigger* trigger = MRGSNotificationTrigger.TriggerWithUnixTime(1287623847623); //In UTC

Step 3. Sending🔗

To send a notification, use the following method:

MRGSNotificationCenter.Instance.Add(notification);

Example🔗

MRGSNotificationCenter.Instance.Delegate = this;

// Sending:
MRGSNotification notification = MRGSNotification.Create(title: "titleUnity", body: "bodyUnity", identifier: 1234, timeInterval: 7);

notification.DeveloperPayload = new Dictionary<string,object>();
notification.DeveloperPayload["unity1"] = "TESTUSERINFO";
notification.DeveloperPayload["unity2"] = 1;

notification.IosExtraOptions.ThreadIdentifier = "unityTheread1";
notification.IosExtraOptions.CategoryIdentifier = "categoryOnReturnNotifications";

notification.AndroidExtraOptions.GroupId = 3;
notification.AndroidExtraOptions.ChannelGroupId = "testChannel";

MRGSNotificationCenter.Instance.Add(notification);

// Receiving:
public void OnNotificationReceive(MRGSNotification notification)
{
    bool isRemote = notification.Trigger.TriggerType == MRGSNotificationTrigger.Type.Remote;
    Debug.Log("MRGSNotification received: " + notification);
    Debug.Log("Remote: " + isRemote);
}

public void OnNotificationClick(MRGSNotification notification)
{
    bool isRemote = notification.Trigger.TriggerType == MRGSNotificationTrigger.Type.Remote;
    Debug.Log("MRGSNotification clicked: " + notification);
    Debug.Log("Remote: " + isRemote);
}

Advanced notification settings, additional features🔗

MRGS allows you to work with all the features and novelties in notifications, namely:

1. Request permission to send notifications at the time you need (on iOS).
2. Get notification settings of the user.
3. Work with delivered and scheduled notifications.
4. Add buttons to notifications and customize their appearance.
5. Manage notification grouping in IOS 12+, including the summary view and its arguments.
6. Add attachments to notifications.
7. Add custom sounds to notifications.
8. The convenient way to turn on and off notifications on the client with just one method call, and we will take care of canceling notifications or invalidating the token (feature is useful for projects with a switch for notifications availability in the settings)
9. Put the number on the iOS application icon.
10. Work with Trial notifications on iOS.

To check out the documentation on these functions, go to the next section - customization and additional features.