Базовый модуль🔗

public class MRGSPostBuildProcessSample
{
    [PostProcessBuild]
    public static void PostProcessBuild(BuildTarget target, string path)
    {
        string plistPath = path + "/Info.plist";
        PlistDocument plist = new PlistDocument();
        plist.ReadFromString(File.ReadAllText(plistPath));
        PlistElementDict rootDict = plist.root;

        // Adding descriptions
        rootDict.SetString("NSUserTrackingUsageDescription", 
                           "This identifier will be used to deliver personalized ads to you.");
    }
}

<iosPListUpdates>
    <addElements tag="dict">
        <key>NSUserTrackingUsageDescription</key>
        <string>This identifier will be used to deliver personalized ads to you.</string>
    </addElements>
</iosPListUpdates>

<key>NSUserTrackingUsageDescription</key>
<string>This identifier will be used to deliver personalized ads to you.</string>

bool should = MRGSDevice.Instance.ShouldShowTrackingAuthorizationDialog();

bool ShouldShow = FMRGSDevice::Get().ShouldShowTrackingAuthorizationDialog();

BOOL should = [[MRGSDevice currentDevice] shouldShowTrackingAuthorizationDialog];

// public void RequestTrackingAuthorization(Action<MRGSIDFATrackingAuthorizationStatus> completion);

MRGSDevice.Instance.RequestTrackingAuthorization((MRGSIDFATrackingAuthorizationStatus status) => {
    // Handle the result
});

public enum MRGSIDFATrackingAuthorizationStatus
{
    /// Request window wasn't shown to user at all
    NotDetermined = 0,
    /// User switched off tracking  in device settings
    Restricted = 1,
    /// User asked app not to track in request window (or later in device settings)
    Denied = 2,
    /// User has granted permission to track
    Authorized = 3,
}

#include "MRGSDevice.h"

FMRGSDevice::Get().RequestTrackingAuthorization([](EMRGSIDFATrackingAuthorizationStatus Status) {
    // Handle the result
});

/**
 * Describe the status of the user's tracking permission request (IDFA request on iOS 14+).
 */
enum MRGSERVICE_API EMRGSIDFATrackingAuthorizationStatus
{
    /**
     * Request window was not shown to user at all.
     */
    NotDetermined = 0,
    /**
     * User switched off tracking in device settings.
     */
    Restricted = 1,
    /**
     * User asked app not to track in request window (or later in device settings).
     */
    Denied = 2,
    /**
     * User has granted permission to track.
     */
    Authorized = 3
};

// - (void)requestTrackingAuthorizationWithCompletionHandler:(void (^)(MRGSIDFATrackingAuthorizationStatus status))completion;

[[MRGSDevice currentDevice] requestTrackingAuthorizationWithCompletionHandler:^(MRGSIDFATrackingAuthorizationStatus status) {
    // Process result
}];

typedef NS_ENUM(NSUInteger, MRGSIDFATrackingAuthorizationStatus) {
    /// Request window wasn't shown to user at all
    MRGSIDFATrackingAuthorizationStatusNotDetermined = 0,
    /// User switched off tracking  in device settings
    MRGSIDFATrackingAuthorizationStatusRestricted,
    /// User asked app not to track in request window (or later in device settings)
    MRGSIDFATrackingAuthorizationStatusDenied,
    /// User has granted permission to track
    MRGSIDFATrackingAuthorizationStatusAuthorized
};

// public MRGSIDFATrackingAuthorizationStatus CurrentTrackingAuthorizationStatus { get; set; }

MRGSIDFATrackingAuthorizationStatus status = MRGSDevice.Instance.CurrentTrackingAuthorizationStatus;

#include "MRGSDevice.h"

EMRGSIDFATrackingAuthorizationStatus Status = FMRGSDevice::Get().GetCurrentTrackingAuthorizationStatus();

// @property (nonatomic, readonly, assign) MRGSIDFATrackingAuthorizationStatus currentTrackingAuthorizationStatus;

MRGSIDFATrackingAuthorizationStatus status = [MRGSDevice currentDevice].currentTrackingAuthorizationStatus;

MRGServiceParams serviceParams = mew MRGServiceParams(appId: MRGS_APP_ID, appSecret: CLIENT_SECRET)  

// Request permission immediately after start 
serviceParams.IOSExtraOptions.AutomaticallyShowIDFARequestAtStartup = true;

// Additional configuration and initialization of MRGS
// ...

#include "MRGSDevice.h"

FMRGServiceParams ServiceParams;

// Request permission immediately after start
ServiceParams.IOSExtraOptions.bShouldRequestIdfaAtStartup = true;

// Additional configuration and initialization of MRGS
// ...

// MRGService settings
MRGServiceParams *mrgsParams = [[MRGServiceParams alloc] initWithAppId: <MRGS_APP_ID> secret: <CLIENT_SECRET>];

// Request permission immediately after start
mrgsParams.automaticallyShowIDFARequestAtStartup = YES;

// Additional configuration and initialization of MRGS
// ...

bool hasAgreed = MRGSDevice.Instance.HasUserAgreedToBeTracked();

bool HasAgreed = FMRGSDevice::Get().HasUserAgreedToBeTracked();

BOOL  hasAgreed =  [[MRGSDevice currentDevice] hasUserAgreedToBeTracked];

MRGSDevice.Instance.OpenSystemSettingsOfApplication();

FMRGSDevice::Get().OpenApplicationSystemSettings();

[MRGSDevice openSystemSettingsOfApplication];

MRGSDevice.getInstance().openSystemSettingsOfApplication();

// Setting options
var options = new MRGSShareOptions()
{
    Text = "Hello from MRGS!",
    Subject = "MRGS Sample App",
    Title = "MRGS Share Title",
    Url = "https://mrgs.astrum.team",
    EmailRecipients = new List<string>{"games.services@my.games"}
};

var image = new Texture2D(128, 128);
options.AddImage(image);

var soundFilePath = System.IO.Directory.GetParent(Application.dataPath) + "/" + "CustomNotificationSound.caf";
options.AddFile(soundFilePath);

// Show dialog
MRGSApplication.Instance.Share(options, (result, error) =>
{
    Debug.Log("MRGSApplication#Share Result - " + result + ". Error - " + error);
});

// Setting options
MRGSShareOptions* options = [[MRGSShareOptions alloc] init];
options.text = @"Hello from MRGS!";
options.subject = @"MRGS Sample App";
options.url = @"https://mrgs.astrum.team";
[options addImage:[UIImage imageNamed:@"MRGSLogo"] withName:@"Logo.png"];
[options addFile:[[NSBundle mainBundle] URLForResource:@"custom_coppa_birthday" withExtension:@"html"].path];
options.emailRecipients = @[@"games.services@my.games"];

// Show dialog
[[MRGSApplication currentApplication] share:options completionHandler:^(MRGSShareResult * _Nullable result, NSError * _Nullable error) {
    NSLog(@"Received share result - %@", result);
}];

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import java.io.File;
import java.util.Collections;
import games.my.mrgs.MRGSApplication;
import games.my.mrgs.MRGSError;
import games.my.mrgs.MRGSShareOptions;
import games.my.mrgs.MRGSShareResult;
import games.my.mrgs.utils.optional.BiConsumer;

// Setting options
final File imageFile = new File("path_to_my_image");
final MRGSShareOptions shareOptions = MRGSShareOptions.newBuilder()
    .setTitle("MRGS Share Title")
    .setSubject("MRGS Subject")
    .setText("Some text for image")
    .setFiles(Collections.singletonList(imageFile.getPath()))
    .setEmailRecipients(Collections.singletonList("test@test.test"))
    .build();

// Show dialog
MRGSApplication.getInstance().share(context, shareOptions, new BiConsumer<MRGSShareResult, MRGSError>()
{
    @Override
    public void accept(@NonNull MRGSShareResult result, @Nullable MRGSError error) {
        // Handle result here.
    }
});

// Getting the device locale
string MRGSDevice.Instance.Country;

// Get the device name
string MRGSDevice.Instance.Model;

// Get platform name
string MRGSDevice.Instance.Platform;

// If the device is jailbroken (worth a jailbreak), then true will return.
bool MRGSDevice.Instance.HasJailbreak;

// Convert SystemLanguage to ISO 639-1 format ("german" -> "de").
string MRGSUtils.SystemLanguageToISO(SystemLanguage language);

// Getting the device locale
FString FMRGSDevice::Get().GetCountry();

// Get the device name
FString FMRGSDevice::Get().GetDeviceModel();

// Get platform name
FString FMRGSDevice::Get().GetPlatform();

// If the device is jailbroken (worth a jailbreak), then true will return.
bool FMRGSDevice::Get().HasJailbreak();

// Getting the device locale
+ (NSString*)country;

// String representation of the device name
@property (nonatomic, readonly, copy) NSString* model;

// Get platform name
@property (nonatomic, readonly, copy) NSString* platform;

// If the device is jailbroken (worth a jailbreak), then true will return.
- (BOOL)isDeviceJailbreak;

// Get the device locale
MRGSDevice.getInstance().getCountry();

// Get the device name
MRGSDevice.getInstance().getModel();

// Get platform name
MRGSDevice.getInstance().getPlatform();

// Callback way
MRGSDevice.Instance.GetOpenUDID(udid => {
    // Handle the result
});

// Async/await way
var openUdid = await MRGSDevice.Instance.GetOpenUDIDAsync();

// Callback way
FMRGSDevice::Get().GetOpenUDID([](FString Udid) {
    // Handle the result          
});

// + (NSString*)openUDID;
NSString* udid = [MRGSDevice openUDID];

// public interface CallbackOpenUDID {
//     void result(String openUDID);
// }

MRGSDevice.getInstance().getOpenUDID(CallbackOpenUDID);

// IDFA synchronous way
MRGSDevice.Instance.AdvertisingIdentifier;

// Asynchronous way
// Return IDFA for Apple store, GAID for Amazon, Google and Samsung stores, OAID for Huawei store,
// or null for other stores.
MRGSDevice.Instance.GetIdentifierForAdvertising(Action<string, MRGSError>);

// Async/await way
var (id, error) = await MRGSDevice.Instance.GetIdentifierForAdvertisingAsync();
var id = await MRGSDevice.Instance.GetIdentifierForAdvertisingAsync().Throwable();

// IDFV only iOS
MRGSDevice.Instance.IdentifierForVendor;

// Return IDFV for Appse store, AppSet id for Google store, ODID for Huawei store or null for other stores.
MRGSDevice.Instance.GetIdentifierForVendor(Action<string, MRGSError>);

// Async/await way
var (id, error) = await MRGSDevice.Instance.GetIdentifierForVendorAsync();
var id = await MRGSDevice.Instance.GetIdentifierForVendorAsync().Throwable();

// Return IDFA for Apple store, GAID for Amazon, Google and Samsung stores, OAID for Huawei store,
// or null for other stores.
FMRGSDevice::Get().GetAdvertisingId(TFunction<void(FAdvertisingIdPtr, FErrorPtr)>);

// Return IDFV for Appse store, AppSet id for Google store, ODID for Huawei store or null for other stores.
FMRGSDevice::Get().GetVendorId(TFunction<void(FAdvertisingIdPtr, FErrorPtr)>);

//IDFA
[[MRGSDevice currentDevice] advertisingIdentifier];

// IDFV
[[MRGSDevice currentDevice] identifierForVendor];

// IDFA
// Return an advertising identifier (GAID for Amazon, Google, Samsung stores
// or OAID for Huawei store). For other storages will return null.
MRGSDevice.getInstance().getAdvertisingId(Context, AdvertisingIdCallback);

// Return AppSet id for Google store, ODID for Huawei store or null for other stores.
MRGSDevice.getInstance().getVendorId(Context, OnVendorIdCallback);

// Returns INSTALL_REFERER for Android,
// and for iOS, the URL with which the application was launched
MRGService.Instance.GetInstallReferer();

// Returns INSTALL_REFERRER for Android, 
// and for iOS, the URL with which the application was launched
FMRGService::Get().GetInstallReferrer();

// The URL with which the application was launched
[MRGService sharedInstance].launchedUrl;

// Returns INSTALL_REFERER.
MRGSBroadcastReceiver.restoreReferer();

// Get the server time at the current moment.
// It will return the real current, not cached server time
MRGService.Instance.ServerTime;

// Get the server time at the current moment.
// It will return the real current, not cached server time
FMRGService::Get().GetServerTime();

// Get the server time at the current moment.
// It will return the real current, not cached server time
[MRGService sharedInstance].serverTime;

// Get the server time at the current moment.
// It will return the real current, not cached server time
MRGService.getInstance().getServerTime();

// Callback way
MRGSDevice.Instance.GetGeoIpInfo((geoIpInfo, error) => {
    if (geoIpInfo != null)
    {
        Debug.Log("MRGSDevice - MRGSGeoIpInfo success: " + geoIpInfo);
    }
    else
    {
        Debug.Log("MRGSDevice - MRGSGeoIpInfo failed: " + error);
    }
});

// Async/await way
var (geoIpInfo, error) = await MRGSDevice.Instance.GetGeoIpInfoAsync();
// or with throw Exception
var geoIpInfo = await MRGSDevice.Instance.GetGeoIpInfoAsync().Throwable();

FMRGSDevice::Get().GetGeoIpInfo([](FGeoInfoPtr GeoInfo, FErrorPtr Error)
{
    if (GeoInfo.IsValid())
    {
        UE_LOG(LogTemp, Verbose, TEXT("MRGSDevice - MRGSGeoIpInfo success: %s"), GeoInfo->Country);
    }
    else
    {
        UE_LOG(LogTemp, Verbose, TEXT("MRGSDevice - MRGSGeoIpInfo failed: %s"), Error->Message);
    }
});

[[MRGSDevice currentDevice] getGeoIpInfo:^(MRGSGeoIpInfo* _Nullable info, NSError* _Nullable error) {
    if(!error){
        NSLog(@"Received geoIp info: %@", info);
    }else{
        NSLog(@"Received geoIp error: %@", error.localizedDescription);
    }
}];

import android.util.Log;

import androidx.annotation.Nullable;

import games.my.mrgs.MRGSDevice;
import games.my.mrgs.MRGSError;
import games.my.mrgs.MRGSGeoIpInfo;
import games.my.mrgs.utils.optional.BiConsumer;

MRGSDevice.getInstance().getGeoIpInfo(new BiConsumer<MRGSGeoIpInfo, MRGSError>() {
    @Override
    public void accept(@Nullable MRGSGeoIpInfo geoIpInfo, @Nullable MRGSError error) {
        if (geoIpInfo != null) {
            Log.d("MRGSDevice", "MRGSGeoIpInfo success: " + geoIpInfo);
        } else {
            Log.d("MRGSDevice", "MRGSGeoIpInfo failed: " + error);
        }
    }
    });

// Unix time in seconds
var installTimeInSec = MRGSApplication.Instance.InstallTime;

// Unix time in seconds
int64 InstallTimeInSec = FMRGSApplication::Get().GetInstallTime();

NSDate *installDate = [NSDate dateWithTimeIntervalSince1970:[MRGSApplication currentApplication].applicationInstallTime];

import games.my.mrgs.MRGSApplication;

// Unix time in milliseconds
final long installTimeInMs = MRGSApplication.getInstance().getInstallTime();