Login with VKontakte🔗

using MRGS;

public class MasterController : MonoBehaviour
{
    void Awake()
    {
        // Setting up mrgs params
        // ...

        var modulesParams = new List<MRGSExternalSDKSettings>
        modulesParams.Add(new MRGSVKontakteParams("<VKontakte_APP_ID>"))
        // Setting up external sdk params
        // ...

        MRGService.Instance.Initialize(serviceParams, sdkParams)
    }
}

@import MRGService;

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    //Setting up mrgs params
    // ...
    //Setting up external sdk params

    MRGSVKontakteParams* VKontakteLoginParams = [[MRGSVKontakteParams alloc] initWithAppId:@"<VKontakte_APP_ID>"];

    NSArray *externalParams = @[ ..., VKontakteLoginParams];
    [MRGService startWithServiceParams:<params> externalSDKParams:externalParams delegate:nil];
}

import java.util.ArrayList;
import java.util.List;

import games.my.mrgs.MRGSModuleParams;
import games.my.mrgs.MRGService;
import games.my.mrgs.authentication.vk.MRGSVKAuthParams;

public class YourApplicationClass extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        // Setting MRGService
        final MRGServiceParams serviceParams = ...;
        // Setting External SDKs
        final List<MRGSModuleParams> moduleParams = new ArrayList<>();
        moduleParams.add(MRGSVKAuthParams.init());

        MRGService.service(context, serviceParams, moduleParams);
    }
}

// Setting
// 'this' conforms to 'IMRGSAuthenticationDelegate' protocol
MRGSAuthenticationVKontakte.Instance.Delegate = this;

// Implementation
// The method that is called when the user has logged out of the social network remotely, or his session has ended.
public void OnAuthenticationProviderDidLogoutUser(MRGSAuthentication provider, MRGSAuthenticationUser user){
    Debug.Log("MRGSAuthentication<Unity> - OnAuthenticationProviderDidLogoutUser: " + user + "\nNetwork: " + provider.SocialId().ToString());
}

//Set
[MRGSAuthenticationVKontakte sharedInstance].delegate = self;

//Implementation
//The method that is called when the user remotely logs out of the social network, or his session ends.
- (void)authenticationProvider:(id<MRGSAuthentication>)provider didLogoutUser:(MRGSAuthenticationUser *)user{
    NSLog(@"User did logout: \n%@", user);
}

//The method that is called when the controller needs to be displayed to authorize the user.
- (void)shouldPresentAuthorizationController:(UIViewController *)viewController {
    UIViewController *rootVC = [UIApplication sharedApplication].keyWindow.rootViewController;
    [rootVC presentViewController:viewController animated:YES completion:nil];
}

import androidx.annotation.NonNull;

import games.my.mrgs.authentication.MRGSAuthentication.OnExternalLogoutListener;
import games.my.mrgs.authentication.vk.MRGSVK;

// Set a listener
MRGSVK.getInstance().setOnExternalLogoutListener(new OnExternalLogoutListener() {
    @Override
    public void onUserLogout(@NonNull String socialId) {
        // Handel result.
    }
});

bool isLoggedIn = MRGSAuthenticationVKontakte.Instance.IsLoggedIn();

BOOL isLoggedIn = [[MRGSAuthenticationVKontakte sharedInstance] isLoggedIn];

import games.my.mrgs.authentication.vk.MRGSVK;

final boolean isLoggedIn = MRGSVK.getInstance().isLoggedIn();

// If error occured, error object will be non-null
MRGSAuthenticationVKontakte.Instance.Login((MRGSError error) => {
    if (error == null) {
        // Auth success
    } 
});

// The response will include an object describing the user and the token, and an error object, if any.
MRGSAuthenticationVKontakte.Instance.Login((MRGSAuthenticationCredential credentials, MRGSError error) => {
    Debug.Log("MRGSAuthenticationVKontakte:\nCredentials: " + credentials + "\nError:\n" + error);
    if (error == null) {
        // Auth success
    }
});

// Only the object of the error will come in the answer, if it happened
[[MRGSAuthenticationVKontakte sharedInstance] login:^(NSError *error) {
    if (!error) {
        // Auth success
    }
}];

//The response will contain an object describing the user and the token, and the object of the error if it happened
[[MRGSAuthenticationVKontakte sharedInstance] loginWithCompletionHandler:^(MRGSAuthenticationCredential *credentials, NSError *error) {
    NSLog(@"Result - %@. Error - %@", credentials, error);
    if (!error) {
        // Auth success
    }
}];

import android.app.Activity;

import androidx.annotation.NonNull;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.MRGSCredentials;
import games.my.mrgs.authentication.MRGSLoginCallback;
import games.my.mrgs.authentication.vk.MRGSVK;

MRGSVK.getInstance().login(activity, new MRGSLoginCallback() {
    @Override
    public void onSuccess(@NonNull MRGSCredentials credentials) {
        // Handle result.
    }

    @Override
    public void onError(@NonNull MRGSError error) {
        // Handle error.
    }
});

* Email - MRGSAuthenticationVKontakte.Scopes.Email
* Friends list - MRGSAuthenticationVKontakte.Scopes.Friends
* Post on user wall - MRGSAuthenticationVKontakte.Scopes.Wall
* Groups api (join, leave, check status) - MRGSAuthenticationVKontakte.Scopes.Groups
* Uploading user photos - MRGSAuthenticationVKontakte.Scopes.Photos
* Checking user status - MRGSAuthenticationVKontakte.Scopes.Status

* Email - kMRGSAuthenticationVKontakteScopeEmail
* Friends list - kMRGSAuthenticationVKontakteScopeFriends
* Post on user wall - kMRGSAuthenticationVKontakteScopeWall
* Groups api (join, leave, check status) - kMRGSAuthenticationVKontakteScopeGroups
* Uploading user photos - kMRGSAuthenticationVKontakteScopePhotos
* Checking user status - kMRGSAuthenticationVKontakteScopeStatus

* Email - "email"
* Friends list - "friends"
* Post on user wall - "wall"
* Groups api (join, leave, check status) - "groups"
* Uploading user photos - "photos"
* Checking user status - "status"

var scopes = new List<string>();
scopes.Add(MRGSAuthenticationVKontakte.Scopes.Email);
scopes.Add(MRGSAuthenticationVKontakte.Scopes.Friends);
scopes.Add(MRGSAuthenticationVKontakte.Scopes.Wall);
scopes.Add(MRGSAuthenticationVKontakte.Scopes.Groups);
scopes.Add(MRGSAuthenticationVKontakte.Scopes.Photos);
scopes.Add(MRGSAuthenticationVKontakte.Scopes.Status);

MRGSAuthenticationVKontakte.Instance.Login(scopes, (MRGSAuthenticationCredential credentials, MRGSError error) => {
    Debug.Log("MRGSAuthenticationVKontakte:\nCredentials: " + credentials + "\nError:\n" + error);
    if (error == null) {
        // Auth success
    }
});

NSArray* scopesToRequest = @[kMRGSAuthenticationVKontakteScopeEmail,kMRGSAuthenticationVKontakteScopeFriends,kMRGSAuthenticationVKontakteScopeWall,kMRGSAuthenticationVKontakteScopeGroups,kMRGSAuthenticationVKontakteScopePhotos,kMRGSAuthenticationVKontakteScopeStatus];
[[MRGSAuthenticationVKontakte sharedInstance] loginWithScopes:scopesToRequest completionHandler:^(MRGSAuthenticationCredential *credentials, NSError *error) {
    NSLog(@"Result - %@. Error - %@", credentials, error);
}];

import android.app.Activity;

import androidx.annotation.NonNull;

import java.util.Arrays;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.MRGSCredentials;
import games.my.mrgs.authentication.MRGSLoginCallback;
import games.my.mrgs.authentication.vk.MRGSVK;

final List<String> scopes = Arrays.asList("email", "friends", "groups", "wall", "photos", "status");
MRGSVK.getInstance().login(activity, scopes, new MRGSLoginCallback() {
    @Override
    public void onSuccess(@NonNull MRGSCredentials credentials) {
        // Handle result
    }

    @Override
    public void onError(@NonNull MRGSError error) {
        // Handle error.
    }
});

// The information about the user, identifier, name, email, etc.
MRGSAuthenticationVKontakte.Instance.GetCurrentUser((MRGSAuthenticationUser user, MRGSError error) => {
    Debug.Log("MRGSAuthenticationVKontakte:\User: " + user + "\nError:\n" + error);
    if (error == null) {
        // Work with user data
    }
});

// Information about the token, lifetime, etc.
MRGSAuthenticationVKontakte.Instance.GetAccessToken((MRGSAuthenticationAccessToken token, MRGSError error) => {
    Debug.Log("MRGSAuthenticationVKontakte:\Token: " + token + "\nError:\n" + error);
    if (error == null) {
        // Work with token info
    }
    else if (error.Code == (int)MRGSAuthenticationErrorCode.ConnectionFailed)
    {
        // No network, try later     
    }
    else
    {
        // Logout user from app (MRGS will logout automatically in SDK)
    }
});

//An object is returned that combines information about the user (identifier, name, email, etc.) and about the token.
[[MRGSAuthenticationVKontakte sharedInstance] getCredentials:^(MRGSAuthenticationCredential *credentials, NSError *error) {
    NSLog(@"Result - %@. Error - %@", credentials, error);
    if(!error){
        // Credentials data work
    }
}];

//Information about the user, identifier, name, email, etc. is returned separately.
[[MRGSAuthenticationVKontakte sharedInstance] getCurrentUser:^(MRGSAuthenticationUser *user, NSError *error) {
    NSLog(@"User - %@. Error - %@", user, error);
    if(!error){
        // User data work
    }
}];

//Information about token and expiration date
[[MRGSAuthenticationVKontakte sharedInstance] getAccessToken:^(MRGSAuthenticationAccessToken *token, NSError *error) {
    if (!error) {
        NSLog(@"getAccessToken result - %@", token);
    } else {
        NSLog(@"getAccessToken error - %@", error);
    }
}];

import android.util.Log;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.MRGSAccessToken;
import games.my.mrgs.authentication.MRGSAuthentication;
import games.my.mrgs.authentication.MRGSUser;
import games.my.mrgs.utils.optional.BiConsumer;
import games.my.mrgs.authentication.vk.MRGSVK;

// Returns user's information.
MRGSVK.getInstance().getCurrentUser(new MRGSAuthentication.UserCallback() {
    @Override
    public void onSuccess(@NonNull final MRGSUser user) {
    }

    @Override
    public void onError(@NonNull MRGSError error) {
    }
});

// Returns authentication's information.
MRGSVK.getInstance().getAccessToken(new BiConsumer<MRGSAccessToken, MRGSError>() {
    @Override
    public void accept(@Nullable MRGSAccessToken accessToken, @Nullable MRGSError error) {
        if (error != null) {
            Log.d("MRGSAuthentication", "AccessToken error: " + error.getErrorText());
        } else {
            Log.d("MRGSAuthentication", "AccessToken success: " + accessToken);
        }
    }
});

MRGSAuthenticationVKontakte.Instance.Logout();

[[MRGSAuthenticationVKontakte sharedInstance] logout];

import games.my.mrgs.authentication.vk.MRGSVK;

MRGSVK.getInstance().logout();

MRGSAuthenticationVKontakte.Instance.GetAvatar("required_user_id", MRGSAuthenticationPhotoSize.Small, (Texture2D avatar, MRGSError error) => {
    if(error == null){
        // Operation completed sucessfully
    }
});

[[MRGSAuthenticationVKontakte sharedInstance] getAvatarForPlayerWithId: @"required_user_id" size:GKPhotoSizeSmall completionHandler:^(UIImage *image, NSError *error) {
    if(!error){
        // Operation completed successfully, work with data
    }
}];

import android.graphics.Bitmap;

import androidx.annotation.NonNull;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.MRGSAvatarCallback;
import games.my.mrgs.authentication.vk.MRGSVK;

// Call #getCurrentUser() to get current user.
final MRGSUser user = ...
// Get user's avatar.
MRGSVK.getInstance().getUserAvatar(user, new MRGSAvatarCallback() {
    @Override
    public void onSuccess(@NonNull Bitmap bitmap) {
        // Handle result.
    }

    @Override
    public void onError(@NonNull MRGSError error) {
        // Handle error.
    }
});

MRGSAuthenticationVKontakte.Instance.GetFriendsIds((List<string> ids, MRGSError error) => {
    if(error == null){
        // Operation completed sucessfully
    }
});

[[MRGSAuthenticationVKontakte sharedInstance] getFriendsIds:^(NSArray *ids, NSError *error) {
    if(!error){
        // Operation completed successfully
    }
}];

import androidx.annotation.NonNull;

import java.util.List;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.MRGSSocial;
import games.my.mrgs.authentication.MRGSUser;
import games.my.mrgs.authentication.vk.MRGSVK;

MRGSVK.getInstance().getFriends(new MRGSSocial.FriendsCallback() {
    @Override
    public void onSuccess(@NonNull List<MRGSUser> users) {
    }

    @Override
    public void onError(@NonNull MRGSError error) {
    }
});

MRGSAuthenticationVKontakte.Instance.GetUser("required_user_id",(MRGSAuthenticationUser user, MRGSError error) => {
    if(error == null){
        // Operation completed sucessfully
    }
});

[[MRGSAuthenticationVKontakte sharedInstance] getUserWithId:@"required_user_id" completionHandler:^(MRGSAuthenticationUser *user, NSError *error) {
    if(!error){
        // Operation completed successfully
    }
}];

import androidx.annotation.NonNull;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.MRGSAuthentication;
import games.my.mrgs.authentication.MRGSUser;
import games.my.mrgs.authentication.vk.MRGSVK;

MRGSVK.getInstance().getUserWithId("userId", new MRGSAuthentication.UserCallback() {
    @Override
    public void onSuccess(@NonNull MRGSUser user) {
    }

    @Override
    public void onError(@NonNull MRGSError error) {
    }
});

MRGSAuthenticationVKontakte.Instance.GetUsers(ids,(List<MRGSAuthenticationUser> users, MRGSError error) => { 
    if(error == null){
        // Operation completed sucessfully
    }
});

[[MRGSAuthenticationVKontakte sharedInstance] getUsersWithIds: @[@"required_user_id_1", @"required_user_id_2"] completionHandler:^(NSArray<MRGSAuthenticationUser*>* users, NSError *error) {
    if(!error){
        // Operation completed successfully
    }
}];

import androidx.annotation.NonNull;

import java.util.Arrays;
import java.util.List;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.MRGSSocial;
import games.my.mrgs.authentication.MRGSUser;
import games.my.mrgs.authentication.vk.MRGSVK;

MRGSVK.getInstance().getUsersWithId(Arrays.asList("user_id_1", "user_id_2"), new MRGSSocial.FriendsCallback() {
    @Override
    public void onSuccess(@NonNull List<MRGSUser> users) {
    }

    @Override
    public void onError(@NonNull MRGSError error) {
    }
});

var post = new MRGSAuthenticationPost();
post.Caption = "MRGS Framework - powerful tool for game development.";
post.Link = "http://mrgs.astrum.team";
post.Message = "Check out MRGS site!";
post.LocalImageURL = System.IO.Path.Combine(Application.dataPath.Replace("/Data", ""), "forest.jpg");

MRGSAuthenticationVKontakte.Instance.ShowPostOnWallDialog(post, (MRGSError error) => {
    if(error == null){
        // Operation completed successfully
    }
});

post.caption = @"MRGS Framework - powerful tool for game development.";
post.link = @"http://mrgs.astrum.team";
post.message = @"Check out MRGS site!";
post.image = [UIImage imageNamed:@"MRGSLogo"];

[[MRGSAuthenticationVKontakte sharedInstance] showPostOnWallDialog:post completionHandler:^(NSError *error) {
    if(!error){
        // Operation completed successfully
    }
}];

Opening a dialog is not supported in VK SDK 2.x, use the postOnWall method

//  Sending invite in game
var inviteIn = new MRGSAuthenticationInvite();
inviteIn.Message = @"Test invite message";
inviteIn.UserIdsToInvite = new List<string>() { "30907315" };

MRGSAuthenticationVKontakte.Instance.SendInvite(inviteIn, (MRGSAuthenticationInvite inviteOut, MRGSError error) => {
    if(error == null){
        // Operation completed sucessfully
        Debug.Log("Sended invite - " + inviteOut);
    }
});

// Sanding game request
var inviteIn = new MRGSAuthenticationInvite();
inviteIn.Message = @"Test invite message";
inviteIn.UserIdsToInvite = new List<string>() { "30907315" }; 

MRGSAuthenticationVKontakte.Instance.SendGameRequest(inviteIn, (MRGSAuthenticationInvite inviteOut, MRGSError error) => {
    if(error == null){
        // Operation completed sucessfully
        Debug.Log("Sended game request - " + inviteOut);
    }
});

// Sending invite in game
MRGSAuthenticationInvite *invite = [[MRGSAuthenticationInvite alloc] init];
invite.message = @"Test invite message";
invite.userIdsToInvite = @[@"30907315"];

[[MRGSAuthenticationVKontakte sharedInstance] sendInvite:invite completionHandler:^(MRGSAuthenticationInvite* inviteOut,NSError *error) {
    if(!error){
        // Operation completed sucessfully
        NSLog(@"Sended invite - %@", inviteOut);
    }
}];

// Sending game request
MRGSAuthenticationInvite *invite = [[MRGSAuthenticationInvite alloc] init];
invite.message = @"Test invite message";
invite.userIdsToInvite = @[@"30907315"];

[[MRGSAuthenticationVKontakte sharedInstance] sendGameRequest:invite completionHandler:^(MRGSAuthenticationInvite* inviteOut, NSError *error) {
    if(!error){
        // Operation completed sucessfully
        NSLog(@"Sended request - %@", inviteOut);
    }
}];

import androidx.annotation.NonNull;

import java.util.Collections;
import java.util.List;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.MRGSSocial;
import games.my.mrgs.authentication.vk.MRGSVK;

// Send invite request
MRGSVK.getInstance().sendGameRequest("Game Request",
        "Invite message", 
        true,
        Collections.singletonList(friend), 
        new MRGSSocial.GameRequestResultCallback() {
            @Override
            public void onSuccess(@NonNull List<String> users) {
                //users were invited in game
            }

            @Override
            public void onError(@NonNull MRGSError error) {
            }
        });

// Send game request
MRGSVK.getInstance().sendGameRequest("Game Request", 
        "Game request message", 
        false,
        Collections.singletonList(friend),
        new MRGSSocial.GameRequestResultCallback() {
            @Override
            public void onSuccess(@NonNull List<String> users) {
                //users were invited in game
            }

            @Override
            public void onError(@NonNull MRGSError error) {
            }
        });

// Post on current user's wall
var post = new MRGSAuthenticationPost();
post.Caption = @"MRGS Framework - powerful tool for game development.";
post.Link = @"http://mrgs.astrum.team";
post.Message = @"Check out MRGS site!";
post.LocalImageURL = System.IO.Path.Combine(Application.dataPath.Replace("/Data", ""), "forest.jpg");

MRGSAuthenticationVKontakte.Instance.SendPostOnWall(post, (MRGSError error) => {
    if(error == null){
        // Operation completed successfully
    }
});

// Posting on another user's wall
var post = new MRGSAuthenticationPost();
post.Caption = @"MRGS Framework - powerful tool for game development.";
post.Link = @"http://mrgs.astrum.team";
post.Message = @"Check out MRGS site!";
post.LocalImageURL = System.IO.Path.Combine(Application.dataPath.Replace("/Data", ""), "forest.jpg");

MRGSAuthenticationVKontakte.Instance.SendPostOnWall(post, "dest_user_id", (MRGSError error) => {
    if(error == null){
        // Operation completed successfully
    }
});

// Post on current user's wall
MRGSAuthenticationPost *post = [[MRGSAuthenticationPost alloc] init];
post.caption = @"MRGS Framework - powerful tool for game development.";
post.link = @"http://mrgs.astrum.team";
post.message = @"Check out MRGS site!";
post.image = [UIImage imageNamed:@"MRGSLogo"];

[[MRGSAuthenticationVKontakte sharedInstance] sendPostOnWall:post completionHandler:^(NSError *error) {
    if(!error){
        // Operation completed successfully
    }
}];

// Post on user wall
MRGSAuthenticationPost *post = [[MRGSAuthenticationPost alloc] init];
post.caption = @"MRGS Framework - powerful tool for game development.";
post.link = @"http://mrgs.astrum.team";
post.message = @"Check out MRGS site!";
post.image = [UIImage imageNamed:@"MRGSLogo"];

[[MRGSAuthenticationVKontakte sharedInstance] sendPostOnWall:post toUserWithId:@"345031059" completionHandler:^(NSError *error) {
    if(!error){
        // Operation completed successfully
    }
}];

import androidx.annotation.NonNull;

import java.util.Arrays;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.vk.MRGSVK;
import games.my.mrgs.authentication.vk.MRGSVK.MRGSVKPostOnWall;

final MRGSVKPostOnWall post = new MRGSVKPostOnWall();
// You can set current vk user id or id or another vk user 
post.setUserId("userId to send");
post.setMessage("Text message");
post.setPhotoUris(Arrays.asList("file:///", "https://"));
// Publish only for friends
post.setFriendsOnly(onlyForFriends);

MRGSVK.getInstance().postOnWall(post, new MRGSVK.MRGSPostOnWallCallback() {
    @Override
    public void onSuccess(int postId) {
    }

    @Override
    public void onError(@NonNull MRGSError error) {
    }
});

// Get a list of friends who installed your application
MRGSAuthenticationVKontakte.Instance.GetInAppFriendsIds((List<string> ids, MRGSError error) => {
    if(error == null){
        // Operation completed sucessfully
    }
});

// Getting a list of friends to whom you can send an invitation to install the application (that is, those who did not install it)
MRGSAuthenticationVKontakte.Instance.GetFriendsIdsAvailableForInvite((List<string> ids, MRGSError error) => {
    if(error == null){
        // Operation completed sucessfully
    }
});

// Getting a list of friends to whom you can send a game request (that is, who installed the application)
MRGSAuthenticationVKontakte.Instance.GetFriendsIdsAvailableForGameRequest((List<string> ids, MRGSError error) => {
    if(error == null){
        // Operation completed sucessfully
    }
});

// Get a list of friends who installed your application
[[MRGSAuthenticationVKontakte sharedInstance] getInAppFriendsIds:^(NSArray *ids, NSError *error) {
    if(!error){
        // Operation completed sucessfully
    }
}];

// Getting a list of friends to whom you can send an invitation to install the application (that is, those who did not install it)
[[MRGSAuthenticationVKontakte sharedInstance] getFriendsIdsAvailableForInvite:^(NSArray *ids, NSError *error) {
    if(!error){
        // Operation completed sucessfully
    }
}];

// Getting a list of friends to whom you can send a game request (that is, who installed the application)
[[MRGSAuthenticationVKontakte sharedInstance] getFriendsIdsAvailableForGameRequest:^(NSArray *ids, NSError *error) {
    if(!error){
        // Operation completed sucessfully
    }
}];

import androidx.annotation.NonNull;

import java.util.List;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.vk.MRGSVK;
import games.my.mrgs.authentication.vk.MRGSVK.MRGSUserIdsCallback;

// Getting a list of friends to whom you can send an invitation to install the application (that is, those who have not installed it)
MRGSVK.getInstance().getFriendsForInvite(new MRGSUserIdsCallback() {
    @Override
    public void onSuccess(@NonNull List<Integer> userIds) {
    }

    @Override
    public void onError(@NonNull MRGSError error) {
    }
});

// Getting a list of friends to whom you can send a game request (that is, those who have installed the application)
MRGSVK.getInstance().getFriendsForGameRequest(new MRGSUserIdsCallback() {
    @Override
    public void onSuccess(@NonNull List<Integer> userIds) {
    }

    @Override
    public void onError(@NonNull MRGSError error) {
    }
});

// Join group
MRGSAuthenticationVKontakte.Instance.JoinGroup("29370987", (MRGSError error) => {
    if(error == null){
        // Operation completed sucessfully
    }
});

// Leave group
MRGSAuthenticationVKontakte.Instance.LeaveGroup("29370987", (MRGSError error) => {
    if(error == null){
        // Operation completed sucessfully
    }
});

// Checking if user member of a group
MRGSAuthenticationVKontakte.Instance.IsGroupMember("29370987", (bool isMember, MRGSError error) => {
    if(error == null){
        // Operation completed sucessfully
        if(isMember == true){
            // Group member
        }else{
            // Not group member
        }
    }
});

// Join group
[[MRGSAuthenticationVKontakte sharedInstance] joinGroup:@"29370987" completionHandler:^(NSError *error) {
    if(!error){
        // Operation completed sucessfully
    }
}];

// Leave group
[[MRGSAuthenticationVKontakte sharedInstance] leaveGroup:@"29370987" completionHandler:^(NSError *error) {
    if(!error){
        // Operation completed sucessfully
    }
}];

// Checking if user member of a group
[[MRGSAuthenticationVKontakte sharedInstance] isGroupMember:@"29370987" completionHandler:^(BOOL isMember, NSError *error) {
    if(!error){
        // Operation completed sucessfully
        if(isMember == true){
            // Group member
        }else{
            // Not group member
        }
    }
}];

import androidx.annotation.NonNull;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.vk.MRGSVK;
import games.my.mrgs.authentication.vk.MRGSVK.MRGSGroupCallback;

// Join the group
MRGSVK.getInstance().joinGroup("groupId", new MRGSGroupCallback() {
    @Override
    public void onSuccess(boolean status) {
        //success if status == true
    }

    @Override
    public void onError(@NonNull MRGSError error) {
    }
});

// Leave the group
MRGSVK.getInstance().leaveGroup("groupId", new MRGSGroupCallback() {
    @Override
    public void onSuccess(boolean status) {
        //success if status == true
    }

    @Override
    public void onError(@NonNull MRGSError error) {
    }
});

// Check if the user is the member of this group
MRGSVK.getInstance().isGroupMember("groupId", new MRGSGroupCallback() {
    @Override
    public void onSuccess(boolean status) {
        //success if status == true
    }

    @Override
    public void onError(@NonNull MRGSError error) {
    }
});