ゲームにグループを統合する

Last updated on February 4, 2026

注釈：本資料はAI技術を用いて翻訳されています。

概要

AccelByte Gaming Services (AGS) グループは、プレイヤーがグループを形成し、集まり、交流し、共通の目標を達成するために協力できるようにすることで、プレイヤー間の交流を促進し、全体的なプレイヤーの定着率を向上させる方法をゲーム開発者に提供します。このガイドでは、Client SDKまたはExtend SDKを使用してAGSグループサービスでゲームにグループを統合する方法を学習します。

この記事では、以下の方法について説明します:

• Client SDKまたはExtend SDKを使用してゲームにグループを統合する
• プレイヤーがグループを管理できるようにする
• グループ情報を取得する
• プレイヤーがグループと対話できるようにする
• プレイヤーにグループ関連の通知を送信する

前提条件

以下へのアクセスが必要です:

• AGS管理ポータル
• AccelByte Unreal SDK、Unity SDKまたはExtend SDK(必要な権限を含む):
  • クライアントID
  • クライアントシークレット
• 参照用のAGSグループAPIドキュメント

グループを管理する

以下のセクションでは、ゲームにグループ管理を統合する方法について詳しく説明します。

新しいグループを作成する

名前空間にグループ設定がある場合、プレイヤーが新しいグループを作成できるようにすることができます。グループを作成したプレイヤーは、デフォルトでグループ管理者になります。次の関数を使用して新しいグループを作成します:

Unreal Engine V1

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FAccelByteModelsCreateGroupRequest RequestContent = {};
RequestContent.ConfigurationCode = "YourGroupConfigurationCode";
RequestContent.GroupName = "YourGroupName";
RequestContent.GroupDescription = "YourGroupDescription";
RequestContent.GroupMaxMember = 50;
RequestContent.GroupType = EAccelByteGroupType::PUBLIC;

ApiClient->Group.CreateGroup(RequestContent, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if CreateGroup succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if CreateGroup fails
}));

Unity V1

CreateGroupRequest createGroupRequest = new CreateGroupRequest
{
    configurationCode = "YourGroupConfigurationCode",
    groupName = "YourGroupName",
    groupDescription = "YourGroupDescription",
    groupMaxMember = 50,
    groupType = GroupType.PUBLIC
};

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().CreateGroup(createGroupRequest, result =>
{
    if (result.IsError)
    {
        // Do something if CreateGroup fails
        Debug.Log($"Error CreateGroup, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if CreateGroup succeeds
});

Unreal Engine V2

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FAccelByteModelsCreateGroupRequest RequestContent = {};
RequestContent.ConfigurationCode = "YourGroupConfigurationCode";
RequestContent.GroupName = "YourGroupName";
RequestContent.GroupDescription = "YourGroupDescription";
RequestContent.GroupMaxMember = 50;
RequestContent.GroupType = EAccelByteGroupType::PUBLIC;

ApiClient->Group.CreateV2Group(RequestContent, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if CreateV2Group succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if CreateV2Group fails
}));

Unity V2

CreateGroupRequest createGroupRequest = new CreateGroupRequest
{
    configurationCode = "YourGroupConfigurationCode",
    groupName = "YourGroupName",
    groupDescription = "YourGroupDescription",
    groupMaxMember = 50,
    groupType = GroupType.PUBLIC
};

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().CreateGroupV2(createGroupRequest, result =>
{
    if (result.IsError)
    {
        // Do something if CreateGroupV2 fails
        Debug.Log($"Error CreateGroupV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if CreateGroupv2 succeeds
});

C# Extend SDK

var response = sdk.Group.Group.CreateNewGroupPublicV2Op
    .Execute(new ModelsPublicCreateNewGroupRequestV1()
    {
        ConfigurationCode = "YourGroupConfigurationCode",
        GroupName = "YourGroupName",
        GroupDescription = "YourGroupDescription",
        GroupMaxMember = 50,
        GroupType = ModelsPublicCreateNewGroupRequestV1GroupType.PUBLIC

    }, sdk.Namespace);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupService := &group.GroupService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
configurationCode := "myconfigurationcode"
groupName := "mygroupname"
groupDescription := "mygroupdescription"
groupMaxMember := int32(50)
groupType := groupclientmodels.ModelsUpdateGroupRequestV1GroupTypePUBLIC
body := groupclientmodels.ModelsPublicCreateNewGroupRequestV1 {
    ConfigurationCode: &configurationCode,
    GroupName: &groupName,
    GroupDescription: &groupDescription,
    GroupMaxMember: &groupMaxMember,
    GroupType: &groupType,
}
namespace := "mygame"
input := &group_.CreateNewGroupPublicV2Params{
    Body:      &body,
    Namespace: namespace,
}
result, err := groupService.CreateNewGroupPublicV2Short(input)

Java Extend SDK

final Group groupWrapper = new Group(sdk);
ModelsPublicCreateNewGroupRequestV1 reqBody = ModelsPublicCreateNewGroupRequestV1.builder()
        .configurationCode("YourGroupConfigurationCode")
        .groupName("YourGroupName")
        .groupDescription("YourGroupDescription")
        .groupMaxMember(50)
        .groupType(ModelsPublicCreateNewGroupRequestV1.GroupType.PUBLIC.name())
        .build();

ModelsGroupResponseV1 response;
try {
    response = groupWrapper.createNewGroupPublicV2(CreateNewGroupPublicV2.builder()
            .namespace("<namespace>")
            .body(reqBody)
            .build());
} catch (Exception e) {
    // Do something when there is an error
    return;
}
// Do something if successful

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service
import accelbyte_py_sdk.api.group.models as group_models

result, error = group_service.create_new_group_public_v2(
    body=group_models.ModelsPublicCreateNewGroupRequestV1()
        .with_configuration_code("YourConfigurationCode")
        .with_group_name("YourGroupName")
        .with_group_description("YourGroupDescription")
        .with_group_max_member(50)
        .with_group_type("PUBLIC"),
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループ情報を更新する

グループ名、アイコン、説明、地域、種類など、特定のグループに関連付けられている情報を更新できます。管理者の役割を持つメンバーのみがグループの情報を更新できます。次の関数を使用してグループ情報を更新します:

Unreal Engine V1

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";
bool bCompletelyReplace = true;

FAccelByteModelsGroupUpdatable UpdateContent = {};
UpdateContent.GroupName = "UpdatedGroupName";
UpdateContent.GroupDescription = "UpdatedGroupDescription";
UpdateContent.GroupType = EAccelByteGroupType::PRIVATE;

ApiClient->Group.UpdateGroup(GroupId, bCompletelyReplace, UpdateContent, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if UpdateGroup succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if UpdateGroup fails
}));

Unity V1

string groupId = "YourGroupId";

UpdateGroupRequest updateGroupRequest = new UpdateGroupRequest
{
    groupName = "UpdatedGroupName",
    groupDescription = "UpdatedGroupDescription",
    groupType = GroupType.PRIVATE
};

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().UpdateGroup(groupId, updateGroupRequest, result =>
{
    if (result.IsError)
    {
        // Do something if UpdateGroup fails
        Debug.Log($"Error UpdateGroup, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if UpdateGroup succeeds
});

Unreal Engine V2

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FAccelByteModelsUpdateGroupRequest UpdateContent = {};
UpdateContent.GroupName = "UpdatedGroupName";
UpdateContent.GroupDescription = "UpdatedGroupDescription";
UpdateContent.GroupType = EAccelByteGroupType::PRIVATE;

ApiClient->Group.UpdateV2Group(GroupId, UpdateContent, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if UpdateV2Group succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if UpdateV2Group fails
}));

Unity V2

string groupId = "YourGroupId";

UpdateGroupRequest updateGroupRequest = new UpdateGroupRequest
{
    groupName = "UpdatedGroupName",
    groupDescription = "UpdatedGroupDescription",
    groupType = GroupType.PRIVATE
};

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().UpdateGroupV2(groupId, updateGroupRequest, result =>
{
    if (result.IsError)
    {
        // Do something if UpdateGroupV2 fails
        Debug.Log($"Error UpdateGroupV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if UpdateGroupV2 succeeds
});

C# Extend SDK

string groupId = "<group-id>";

var response = sdk.Group.Group.UpdatePutSingleGroupPublicV2Op
    .Execute(new ModelsUpdateGroupRequestV1()
    {
        GroupName = "YourGroupName",
        GroupDescription = "YourGroupDescription",
        GroupType = ModelsUpdateGroupRequestV1GroupType.PRIVATE

    }, groupId, sdk.Namespace);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupService := &group.GroupService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
groupName := "mygroupname"
groupDescription := "mygroupdescription"
groupType := groupclientmodels.ModelsUpdateGroupRequestV1GroupTypePRIVATE
body := groupclientmodels.ModelsUpdateGroupRequestV1 {
    GroupName: &groupName,
    GroupDescription: &groupDescription,
    GroupType: &groupType,
}
groupId := "mygroupid"
namespace := "mygame"
input := &group_.UpdatePutSingleGroupPublicV2Params{
    Body:      &body,
    GroupID:   groupId,
    Namespace: namespace,
}
result, err := groupService.UpdatePutSingleGroupPublicV2Short(input)

Java Extend SDK

final Group groupWrapper = new Group(sdk);
ModelsUpdateGroupRequestV1 reqBody = ModelsUpdateGroupRequestV1.builder()
        .groupName("UpdatedGroupName")
        .groupDescription("UpdatedGroupDescription")
        .groupType(ModelsPublicCreateNewGroupRequestV1.GroupType.PRIVATE.name())
        .build();
ModelsGroupResponseV1 response;
try {
    response = groupWrapper.updatePutSingleGroupPublicV2(UpdatePutSingleGroupPublicV2.builder()
            .namespace("<namespace")
            .groupId("<groupId>")
            .body(reqBody)
            .build());
} catch (Exception e) {
    // Do something if there is an an error
    return;
}

// Do something if successful

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service
import accelbyte_py_sdk.api.group.models as group_models

result, error = group_service.update_put_single_group_public_v2(
    body=group_models.ModelsUpdateGroupRequestV1()
        .with_group_name("YourGroupName")
        .with_group_description("YourGroupDescription")
        .with_group_type("PRIVATE"),
    group_id="GroupId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループのカスタム属性を更新する

この関数を使用して、グループのカスタム属性を個別に更新できます。グループ情報の更新と同様に、管理者の役割を持つメンバーのみがグループのカスタム属性を更新できます。

Unreal Engine V1

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

FJsonObjectWrapper UpdatedCustomAttributes;
UpdatedCustomAttributes.JsonObject = MakeShared<FJsonObject>();
UpdatedCustomAttributes.JsonObject->SetStringField("Attribute String Key", "Updated Attribute");

FAccelByteModelsUpdateGroupCustomAttributesRequest UpdateContent = {};
UpdateContent.CustomAttributes = UpdatedCustomAttributes;

ApiClient->Group.UpdateGroupCustomAttributes(GroupId, UpdateContent, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if UpdateGroupCustomAttributes succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if UpdateGroupCustomAttributes fails
}));

Unity V1

string groupId = "YourGroupId";

Dictionary<string, object> updateGroupRequest = new Dictionary<string, object>
{
    {"Attribute String Key", "Updated Attribute" }
};

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().UpdateGroupCustomAttributes(groupId, updateGroupRequest, result =>
{
    if (result.IsError)
    {
        // Do something if UpdateGroupCustomAttributes fails
        Debug.Log($"Error UpdateGroupCustomAttributes, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if UpdateGroupCustomAttributes succeeds
});

Unreal Engine V2

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

FJsonObjectWrapper UpdatedCustomAttributes;
UpdatedCustomAttributes.JsonObject = MakeShared<FJsonObject>();
UpdatedCustomAttributes.JsonObject->SetStringField("Attribute String Key", "Updated Attribute");

FAccelByteModelsUpdateGroupCustomAttributesRequest UpdateContent = {};
UpdateContent.CustomAttributes = UpdatedCustomAttributes;

ApiClient->Group.UpdateV2GroupCustomAttributes(GroupId, UpdateContent, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if UpdateV2GroupCustomAttributes succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if UpdateV2GroupCustomAttributes fails
}));

Unity V2

string groupId = "YourGroupId";

Dictionary<string, object> updateGroupRequest = new Dictionary<string, object>
{
    {"Attribute String Key", "Updated Attribute" }
};

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().UpdateGroupCustomAttributesV2(groupId, updateGroupRequest, result =>
{
    if (result.IsError)
    {
        // Do something if UpdateGroupCustomAttributesV2 fails
        Debug.Log($"Error UpdateGroupCustomAttributesV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if UpdateGroupCustomAttributesV2 succeeds
});

C# Extend SDK

string groupId = "<group-id>";

var response = sdk.Group.Group.UpdateGroupCustomAttributesPublicV2Op
    .Execute(new ModelsUpdateGroupCustomAttributesRequestV1()
    {
        CustomAttributes = new Dictionary<string, object>()
        {
            { "Attribute String Key", "Updated Attribute" }
        }
    }, groupId, sdk.Namespace);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupService := &group.GroupService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
body := groupclientmodels.ModelsUpdateGroupCustomAttributesRequestV1 {
    CustomAttributes: map[string]interface{}{
        "Attribute String Key": "Updated Attribute",
    },
}
groupId := "mygroupid"
namespace := "mygame"
input := &group_.UpdateGroupCustomAttributesPublicV2Params{
    Body:      &body,
    GroupID:   groupId,
    Namespace: namespace,
}
result, err := groupService.UpdateGroupCustomAttributesPublicV2Short(input)

Java Extend SDK

final Group groupWrapper = new Group(sdk);
Map<String, String> customAttributesMap = new HashMap<>();
customAttributesMap.put("Attribute String Key", "Updated Attribute");

ModelsUpdateGroupCustomAttributesRequestV1 reqBody = ModelsUpdateGroupCustomAttributesRequestV1.builder()
        .customAttributes(customAttributesMap)
        .build();

ModelsGroupResponseV1 response;
try {
    response = groupWrapper.updateGroupCustomAttributesPublicV2(UpdateGroupCustomAttributesPublicV2.builder()
            .namespace("<namespace")
            .groupId("<groupId>")
            .body(reqBody)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

// Do something if successful

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service
import accelbyte_py_sdk.api.group.models as group_models

result, error = group_service.update_group_custom_attributes_public_v2(
    body=group_models.ModelsUpdateGroupCustomAttributesRequestV1()
        .with_custom_attributes(
            {
                "AttributeKey": "UpdatedAttributeValue",
            }
        ),
    group_id="GroupId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループ情報を表示する

以下のセクションでは、さまざまな種類のグループ情報を表示する方法について詳しく説明します。

グループのリストを取得する

プレイヤーがグループ名または地域を使用して検索することで、プレイヤーが作成した利用可能なグループを検索できるようにすることができます。結果はページに表示され、offsetとlimitパラメータを使用してリストを制限できます。次の関数を使用してグループのリストを取得します:

注記

以下の関数は、PUBLICおよびOPENグループのみを表示します。グループの種類の詳細については、グループとの対話に関するセクションを参照してください。

Unreal Engine

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FAccelByteModelsGetGroupListRequest FilterContent = {};
FilterContent.GroupName = "YourGroupName";
FilterContent.GroupRegion = "US";

ApiClient->Group.GetGroupList(FilterContent, THandler<FAccelByteModelsGetGroupListResponse>::CreateLambda([](const FAccelByteModelsGetGroupListResponse& Result)
{
    // Do something if GetGroupList succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetGroupList fails
}));

Unity

string groupName = "YourGroupName";
string groupRegion = "US";
int limit = 100;
int offset = 0;

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().SearchGroups(groupName, groupRegion, limit, offset, result =>
{
    if (result.IsError)
    {
        // Do something if SearchGroups fails
        Debug.Log($"Error SearchGroups, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if SearchGroups succeeds
});

C# Extend SDK

var response = sdk.Group.Group.GetGroupListPublicV1Op
    .SetGroupName("YourGroupName")
    .SetGroupRegion("US")
    .SetOffset(0)
    .SetLimit(100)
    .Execute(sdk.Namespace);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupService := &group.GroupService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
namespace := "mygame"
groupName := "groupname"
groupRegion := "US"
limit := int64(100)
offset := int64(0)
input := &group_.GetGroupListPublicV1Params{
    Namespace:   namespace,
    GroupName:   &groupName,
    GroupRegion: &groupRegion,
    Limit:       &limit,
    Offset:      &offset,
}
result, err := groupService.GetGroupListPublicV1Short(input)

Java Extend SDK

final Group groupWrapper = new Group(sdk);
ModelsGetGroupsListResponseV1 response;
try {
    response = groupWrapper.getGroupListPublicV1(GetGroupListPublicV1.builder()
            .namespace("<namespace>")
            .groupName("YourGroupName")
            .groupRegion("US")
            .limit(100)
            .offset(0)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.get_group_list_public_v1(
    group_name="YourGroupName",
    group_region="US",
    limit=100,
    offset=0,
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループIDでグループ情報を取得する

プレイヤーにグループに関するより明確な情報を提供するために、次の関数を使用してグループIDを使用してグループに関する情報を取得できます:

Unreal Engine

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.GetGroup(GroupId, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if GetGroup succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetGroup fails
}));

Unity

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetGroup(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if GetGroup fails
        Debug.Log($"Error GetGroup, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetGroup succeeds
});

C# Extend SDK

string groupId = "<group-id>";

var response = sdk.Group.Group.GetSingleGroupPublicV1Op
    .Execute(groupId, sdk.Namespace);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupService := &group.GroupService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
groupId := "mygroupid"
namespace := "mygame"
input := &group_.GetSingleGroupPublicV1Params{
    GroupID:   groupId,
    Namespace: namespace,
}
result, err := groupService.GetSingleGroupPublicV1Short(input)

Java Extend SDK

final Group groupWrapper = new Group(sdk);
String groupId = "YourGroupId";
ModelsGroupResponseV1 response;
try {
    response = groupWrapper.getSingleGroupPublicV1(GetSingleGroupPublicV1.builder()
            .namespace("<namespace>")
            .groupId(groupId)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.get_single_group_public_v1(
    group_id="GroupId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

ユーザーIDでグループ情報を取得する

次の関数を使用して、ユーザーIDを使用してプレイヤーがグループ情報を取得できるようにすることができます:

注記

リクエストしたプレイヤーがどのグループにも属していない場合、返されるステータスはErrorCode.UserNotBelongToAnyGroupになり、プレイヤーはグループに招待できるようになります。

Unreal Engine

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString UserId = "YourUserId";

ApiClient->Group.GetUserGroupInfoByUserId(UserId, THandler<FAccelByteModelsGetUserGroupInfoResponse>::CreateLambda([](const FAccelByteModelsGetUserGroupInfoResponse& Result)
{
    // Do something if GetUserGroupInfoByUserId succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetUserGroupInfoByUserId fails
}));

Unity

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetMyGroupInfo(result =>
{
    if (result.IsError)
    {
        // Do something if GetMyGroupInfo fails
        Debug.Log($"Error GetMyGroupInfo, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetMyGroupInfo succeeds
})

C# Extend SDK

string userId = "<user-id>";

var response = sdk.Group.GroupMember.GetUserGroupInformationPublicV1Op
    .Execute(sdk.Namespace, userId);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupMemberService := &group.GroupMemberService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
namespace := "mygame"
userId := "myuserid"
input := &group_member.GetUserGroupInformationPublicV1Params{
    Namespace: namespace,
    UserID:    userId,
}
result, err := groupMemberService.GetUserGroupInformationPublicV1Short(input)

Java Extend SDK

final GroupMember groupMemberWrapper = new GroupMember(sdk);
String userId = "YourUserId";
ModelsGetUserGroupInformationResponseV1 response;
try {
    response = groupMemberWrapper.getUserGroupInformationPublicV1(GetUserGroupInformationPublicV1.builder()
            .namespace("<namespace>")
            .userId(userId)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.get_user_group_information_public_v1(
    user_id="********************************",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

プレイヤーのグループ情報を取得する

特定のユーザーIDを持つユーザーのグループ情報をプレイヤーが取得できるようにすることができます。

Unreal Engine

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString UserId = "YourUserId";

ApiClient->Group.GetUserGroupInfoByUserId(UserId, THandler<FAccelByteModelsGetUserGroupInfoResponse>::CreateLambda([](const FAccelByteModelsGetUserGroupInfoResponse& Result)
{
    // Do something if GetUserGroupInfoByUserId succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetUserGroupInfoByUserId fails
}));

Unity

string userId = "YourUserId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetOtherGroupInfo(userId, result =>
{
    if (result.IsError)
    {
        // Do something if GetOtherGroupInfo fails
        Debug.Log($"Error GetOtherGroupInfo, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetOtherGroupInfo succeeds
});

C# Extend SDK

string userId = "<user-id>";

var response = sdk.Group.GroupMember.GetUserGroupInformationPublicV1Op
    .Execute(sdk.Namespace, userId);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupMemberService := &group.GroupMemberService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
namespace := "mygame"
userId := "myuserid"
input := &group_member.GetUserGroupInformationPublicV1Params{
    Namespace: namespace,
    UserID:    userId,
}
result, err := groupMemberService.GetUserGroupInformationPublicV1Short(input)

Java Extend SDK

final GroupMember groupMemberWrapper = new GroupMember(sdk);
String userId = "YourUserId";
ModelsGetUserGroupInformationResponseV1 response;
try {
    response = groupMemberWrapper.getUserGroupInformationPublicV1(GetUserGroupInformationPublicV1.builder()
            .namespace("<namespace>")
            .userId(userId)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.get_user_group_information_public_v1(
    user_id="********************************",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループのメンバーリストを取得する

プレイヤーが特定のグループ内のメンバーのリストを取得できるようにすることができます。次の関数を使用して、グループIDを使用してグループのメンバーリストを取得します。

Unreal Engine

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

FAccelByteModelsGetGroupMembersListByGroupIdRequest RequestContent = {};
RequestContent.Limit = 100;
RequestContent.Offset = 0;
RequestContent.SortBy = EAccelByteGroupListSortBy::ASCENDING;

ApiClient->Group.GetGroupMembersListByGroupId(GroupId, RequestContent, THandler<FAccelByteModelsGetGroupMemberListResponse>::CreateLambda([](const FAccelByteModelsGetGroupMemberListResponse& Result)
{
    // Do something if GetGroupMembersListByGroupId succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetGroupMembersListByGroupId fails
}));

Unity

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetGroupMemberList(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if GetGroupMemberList fails
        Debug.Log($"Error GetGroupMemberList, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetGroupMemberList succeeds
});

C# Extend SDK

var response = sdk.Group.GroupMember.GetGroupMembersListPublicV1Op
    .SetOffset(0)
    .SetLimit(100)
    .Execute(groupId, sdk.Namespace);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupMemberService := &group.GroupMemberService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
groupId := "mygroupid"
namespace := "mygame"
limit := int64(100)
offset := int64(0)
input := &group_member.GetGroupMembersListPublicV1Params{
    GroupID:   groupId,
    Namespace: namespace,
    Limit:     &limit,
    Offset:    &offset,
}
result, err := groupMemberService.GetGroupMembersListPublicV1Short(input)

Java Extend SDK

ModelsGetGroupMemberListResponseV1 response;
try {
    response = groupMemberWrapper.getGroupMembersListPublicV1(GetGroupMembersListPublicV1.builder()
            .namespace("<namespace>")
            .groupId(groupId)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.get_group_members_list_public_v1(
    limit=100,
    offset=0,
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループと対話する

以下のセクションでは、プレイヤーとグループの対話について詳しく説明します。

グループに参加する

プレイヤーはOPENまたはPUBLICグループへの参加をリクエストできます。各グループの種類には異なる動作があります:

• OPENグループでは、プレイヤーが自動的に参加できます。
• PUBLICグループでは、プレイヤーがグループに参加する前にグループ管理者が承認する必要がある参加リクエストを行う必要があります。

次の関数を使用して、プレイヤーが特定のグループに参加できるようにします。

Unreal Engine V1

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.JoinGroup(GroupId, THandler<FAccelByteModelsJoinGroupResponse>::CreateLambda([](const FAccelByteModelsJoinGroupResponse& Result)
{
    // Do something if JoinGroup succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if JoinGroup fails
}));

Unity V1

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().JoinGroup(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if JoinGroup fails
        Debug.Log($"Error JoinGroup, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if JoinGroup succeeds
});

Unreal Engine V2

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.JoinV2Group(GroupId, THandler<FAccelByteModelsJoinGroupResponse>::CreateLambda([](const FAccelByteModelsJoinGroupResponse& Result)
{
    // Do something if JoinV2Group succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if JoinV2Group fails
}));

Unity V2

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().JoinGroupV2(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if JoinGroupV2 fails
        Debug.Log($"Error JoinGroupV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if JoinGroupV2 succeeds
});

C# Extend SDK

string groupId = "<group-id>";

var response = sdk.Group.GroupMember.JoinGroupV2Op
    .Execute(groupId, sdk.Namespace);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupMemberService := &group.GroupMemberService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
groupId := "mygroupid"
namespace := "mygame"
input := &group_member.JoinGroupV2Params{
    GroupID:   groupId,
    Namespace: namespace,
}
result, err := groupMemberService.JoinGroupV2Short(input)

Java Extend SDK

final GroupMember groupMemberWrapper = new GroupMember(sdk);
String groupId = "YourGroupId";
ModelsJoinGroupResponseV1 response;
try {
    response = groupMemberWrapper.joinGroupV2(JoinGroupV2.builder()
            .namespace("<namespace>")
            .groupId(groupId)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.join_group_v2(
    group_id="GroupId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

参加リクエストをキャンセルする

プレイヤーがPUBLICグループへの参加をリクエストした後、そのリクエストをキャンセルできます。

Unreal Engine

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.CancelJoinGroupRequest(GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if CancelJoinGroupRequest succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if CancelJoinGroupRequest fails
}));

Unity

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().CancelJoinGroupRequest(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if JoinGroupV2 fails
        Debug.Log($"Error JoinGroupV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if JoinGroupV2 succeeds
});

C# Extend SDK

string groupId = "<group-id>";

var response = sdk.Group.GroupMember.CancelGroupJoinRequestV1Op
    .Execute(groupId, sdk.Namespace);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupMemberService := &group.GroupMemberService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
groupId := "mygroupid"
namespace := "mygame"
input := &group_member.CancelGroupJoinRequestV1Params{
    GroupID:   groupId,
    Namespace: namespace,
}
result, err := groupMemberService.CancelGroupJoinRequestV1Short(input)

Java Extend SDK

final GroupMember groupMemberWrapper = new GroupMember(sdk);
String groupId = "YourGroupId";
ModelsMemberRequestGroupResponseV1 response;
try {
    response = groupMemberWrapper.cancelGroupJoinRequestV1(CancelGroupJoinRequestV1.builder()
            .namespace("<namespace>")
            .groupId(groupId)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.cancel_group_join_request_v1(
    group_id="GroupId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループを離れる

プレイヤーがグループを離れることができるようにするには、次の関数を使用できます:

Unreal Engine V1

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

ApiClient->Group.LeaveGroup(THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if LeaveGroup succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if LeaveGroup fails
}));

Unity V1

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().LeaveGroup(result =>
{
    if (result.IsError)
    {
        // Do something if LeaveGroup fails
        Debug.Log($"Error LeaveGroup, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if LeaveGroup succeeds
});

Unreal Engine V2

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.LeaveV2Group(GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if LeaveV2Group succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if LeaveV2Group fails
}));

Unity V2

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().LeaveGroupV2(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if LeaveGroupV2 fails
        Debug.Log($"Error LeaveGroupV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if LeaveGroupV2 succeeds
});

C# Extend SDK

string groupId = "<group-id>";

var response = sdk.Group.GroupMember.LeaveGroupPublicV2Op
    .Execute(groupId, sdk.Namespace);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupMemberService := &group.GroupMemberService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
groupId := "mygroupid"
namespace := "mygame"
input := &group_member.LeaveGroupPublicV2Params{
    GroupID:   groupId,
    Namespace: namespace,
}
result, err := groupMemberService.LeaveGroupPublicV2Short(input)

Java Extend SDK

    final GroupMember groupMemberWrapper = new GroupMember(sdk);
    String groupId = "YourGroupId";
    ModelsLeaveGroupResponseV1 response;
    try {
      response = groupMemberWrapper.leaveGroupPublicV2(LeaveGroupPublicV2.builder()
              .namespace("<namespace>")
              .groupId(groupId)
              .build());
    } catch (Exception e) {
      // Do something if there is an error
      return;
    }

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.leave_group_public_v2(
    group_id="GroupId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

プレイヤーをグループに招待する

グループ管理者は、プレイヤーを自分のグループに参加するように招待できます。PRIVATEグループは、この関数を使用して新しいメンバーを追加できます。プレイヤーは、グループに参加する前に招待を受け入れる必要があります。

Unreal Engine V1

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString UserId = "YourUserId";

ApiClient->Group.InviteUserToGroup(UserId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if InviteUserToGroup succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if InviteUserToGroup fails
}));

Unity V1

string userId = "YourUserId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().InviteOtherUserToGroup(userId, result =>
{
    if (result.IsError)
    {
        // Do something if InviteOtherUserToGroup fails
        Debug.Log($"Error InviteOtherUserToGroup, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if InviteOtherUserToGroup succeeds
});

Unreal Engine V2

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString UserId = "YourUserId";
FString GroupId = "YourGroupId";

ApiClient->Group.InviteUserToV2Group(UserId, GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if InviteUserToV2Group succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if InviteUserToV2Group fails
}));

Unity V2

string userId = "YourUserId";
string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().InviteOtherUserToGroupV2(userId, groupId, result =>
{
    if (result.IsError)
    {
        // Do something if InviteOtherUserToGroupV2 fails
        Debug.Log($"Error InviteOtherUserToGroupV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    // Do something if InviteOtherUserToGroupV2 succeeds
});

C# Extend SDK

string groupId = "<group-id>";
string userId = "<user-id>";

var response = sdk.Group.GroupMember.InviteGroupPublicV2Op
    .Execute(groupId, sdk.Namespace, userId);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupMemberService := &group.GroupMemberService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
groupId := "mygroupid"
namespace := "mygame"
userId := "myuserid"
input := &group_member.InviteGroupPublicV2Params{
    GroupID:   groupId,
    Namespace: namespace,
    UserID:    userId,
}
result, err := groupMemberService.InviteGroupPublicV2Short(input)

Java Extend SDK

final GroupMember groupMemberWrapper = new GroupMember(sdk);
String groupId = "YourGroupId";
String userId = "YourUserId";
ModelsUserInvitationResponseV1 response;
try {
    response = groupMemberWrapper.inviteGroupPublicV2(InviteGroupPublicV2.builder()
            .namespace("<namespace>")
            .groupId(groupId)
            .userId(userId)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.invite_group_public_v2(
    group_id="GroupId",
    user_id="********************************",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループメンバーを削除/キックする

グループ管理者は、グループメンバーをグループから削除(キック)することもできます。

Unreal Engine V1

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString UserId = "YourUserId";

ApiClient->Group.KickGroupMember(UserId, THandler<FAccelByteModelsKickGroupMemberResponse>::CreateLambda([](const FAccelByteModelsKickGroupMemberResponse& Result)
{
    // Do something if KickGroupMember succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if KickGroupMember fails
}));

Unity V1

string userId = "YourUserId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().KickGroupMember(userId, result =>
{
    if (result.IsError)
    {
        // Do something if KickGroupMember fails
        Debug.Log($"Error KickGroupMember, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    // Do something if KickGroupMember succeeds
});

Unreal Engine V2

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString UserId = "YourUserId";
FString GroupId = "YourGroupId";

ApiClient->Group.KickV2GroupMember(UserId, GroupId, THandler<FAccelByteModelsKickGroupMemberResponse>::CreateLambda([](const FAccelByteModelsKickGroupMemberResponse& Result)
{
    // Do something if KickV2GroupMember succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if KickV2GroupMember fails
}));

Unity V2

string userId = "YourUserId";
string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().KickGroupMemberV2(userId, groupId, result =>
{
    if (result.IsError)
    {
        // Do something if KickGroupMemberV2 fails
        Debug.Log($"Error KickGroupMemberV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if KickGroupMemberV2 succeeds
});

C# Extend SDK

string groupId = "<group-id>";
string userId = "<user-id>";

var response = sdk.Group.GroupMember.KickGroupMemberPublicV2Op
    .Execute(groupId, sdk.Namespace, userId);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupMemberService := &group.GroupMemberService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
groupId := "mygroupid"
namespace := "mygame"
userId := "myuserid"
input := &group_member.KickGroupMemberPublicV2Params{
    GroupID:   groupId,
    Namespace: namespace,
    UserID:    userId,
}
result, err := groupMemberService.KickGroupMemberPublicV2Short(input)

Java Extend SDK

final MemberRequest memberRequestWrapper = new MemberRequest(sdk);
int limit = 100;
int offset = 0;
ModelsGetMemberRequestsListResponseV1 response;
try {
    response = memberRequestWrapper.getGroupInvitationRequestPublicV1(GetGroupInvitationRequestPublicV1.builder()
            .namespace("<namespace>")
            .limit(limit)
            .offset(offset)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

final GroupMember groupMemberWrapper = new GroupMember(sdk);
String groupId = "YourGroupId";
String userId = "YourUserId";
ModelsKickGroupMemberResponseV1 response;
try {
    response = groupMemberWrapper.kickGroupMemberPublicV2(KickGroupMemberPublicV2.builder()
            .namespace("<namespace>")
            .groupId(groupId)
            .userId(userId)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.kick_group_member_public_v2(
    group_id="GroupId",
    user_id="********************************",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループ招待リクエストのリストを取得する

プレイヤーは、グループ招待リクエストのリストを取得して、これらの招待を受け入れるか拒否することができます。

Unreal Engine

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FAccelByteModelsLimitOffsetRequest RequestContent = {};
RequestContent.Limit = 100;
RequestContent.Offset = 0;

ApiClient->Group.GetGroupInvitationRequests(RequestContent, THandler<FAccelByteModelsGetMemberRequestsListResponse>::CreateLambda([](const FAccelByteModelsGetMemberRequestsListResponse& Result)
{
    // Do something if GetGroupInvitationRequests succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetGroupInvitationRequests fails
}));

Unity

int limit = 100;
int offset = 0;

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetGroupInvitationRequests(limit, offset, result =>
{
    if (result.IsError)
    {
        // Do something if GetGroupInvitationRequests fails
        Debug.Log($"Error GetGroupInvitationRequests, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetGroupInvitationRequests succeeds
});

C# Extend SDK

var response = sdk.Group.MemberRequest.GetGroupInvitationRequestPublicV1Op
    .SetOffset(0)
    .SetLimit(100)
    .Execute(sdk.Namespace);
if (response != null)
{
    //do something when success
}

Go Extend SDK

memberRequestService := &group.MemberRequestService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
namespace := "mygame"
limit := int64(100)
offset := int64(0)
input := &member_request.GetGroupInvitationRequestPublicV1Params{
    Namespace: namespace,
    Limit:     &limit,
    Offset:    &offset,
}
result, err := memberRequestService.GetGroupInvitationRequestPublicV1Short(input)

Java Extend SDK

final MemberRequest memberRequestWrapper = new MemberRequest(sdk);
ModelsGetMemberRequestsListResponseV1 response;
try {
    response = memberRequestWrapper.getGroupInvitationRequestPublicV1(GetGroupInvitationRequestPublicV1.builder()
            .namespace("<namespace>")
            .limit(limit)
            .offset(offset)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.get_group_invitation_request_public_v1(
    limit=100,
    offset=0,
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループ招待リクエストを受け入れる

招待リストを取得した後、プレイヤーは招待を受け入れることができます。

Unreal Engine V1

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.AcceptGroupInvitation(GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if AcceptGroupInvitation succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if AcceptGroupInvitation fails
}));

Unity V1

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().AcceptGroupInvitation(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if AcceptGroupInvitation fails
        Debug.Log($"Error AcceptGroupInvitation, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if AcceptGroupInvitation succeeds
});

Unreal Engine V2

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.AcceptGroupInvitation(GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if AcceptGroupInvitation succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if AcceptGroupInvitation fails
}));

Unity V2

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().AcceptGroupInvitationV2(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if AcceptGroupInvitationV2 fails
        Debug.Log($"Error AcceptGroupInvitationV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if AcceptGroupInvitationV2 succeeds
});

C# Extend SDK

string groupId = "<group-id>";

var response = sdk.Group.GroupMember.AcceptGroupInvitationPublicV2Op
    .Execute(groupId, sdk.Namespace);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupMemberService := &group.GroupMemberService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
groupId := "mygroupid"
namespace := "mygame"
input := &group_member.AcceptGroupInvitationPublicV2Params{
    GroupID:   groupId,
    Namespace: namespace,
}
result, err := groupMemberService.AcceptGroupInvitationPublicV2Short(input)

Java Extend SDK

final GroupMember groupMemberWrapper = new GroupMember(sdk);
String groupId = "YourGroupId";
ModelsMemberRequestGroupResponseV1 response;
try {
    response = groupMemberWrapper.acceptGroupInvitationPublicV2(AcceptGroupInvitationPublicV2.builder()
            .namespace("<namespace>")
            .groupId(groupId)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.accept_group_invitation_public_v2(
    group_id="GroupId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループ招待リクエストを拒否する

プレイヤーは、任意の招待リクエストを拒否できます。

Unreal Engine V1

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.RejectGroupInvitation(GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if RejectGroupInvitation succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if RejectGroupInvitation fails
}));

Unity V1

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().RejectGroupInvitation(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if RejectGroupInvitation fails
        Debug.Log($"Error RejectGroupInvitation, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if RejectGroupInvitation succeeds
});

Unreal Engine V2

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.RejectV2GroupInvitation(GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if RejectV2GroupInvitation succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if RejectV2GroupInvitation fails
}));

Unity V2

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().RejectGroupInvitationV2(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if RejectGroupInvitationV2 fails
        Debug.Log($"Error RejectGroupInvitationV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if RejectGroupInvitationV2 succeeds
});

C# Extend SDK

string groupId = "<group-id>";

var response = sdk.Group.GroupMember.RejectGroupInvitationPublicV2Op
    .Execute(groupId, sdk.Namespace);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupMemberService := &group.GroupMemberService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
groupId := "mygroupid"
namespace := "mygame"
input := &group_member.RejectGroupInvitationPublicV2Params{
    GroupID:   groupId,
    Namespace: namespace,
}
result, err := groupMemberService.RejectGroupInvitationPublicV2Short(input)

Java Extend SDK

final GroupMember groupMemberWrapper = new GroupMember(sdk);
String groupId = "YourGroupId";
ModelsMemberRequestGroupResponseV1 response;
try {
    response = groupMemberWrapper.rejectGroupInvitationPublicV2(RejectGroupInvitationPublicV2.builder()
            .namespace("<namespace>")
            .groupId(groupId)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.reject_group_invitation_public_v2(
    group_id="GroupId",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループメンバー参加リクエストのリストを取得する

グループ管理者は、グループメンバー参加リクエストのリストを取得して、それらを承認または拒否できます。

Unreal Engine V1

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

FAccelByteModelsLimitOffsetRequest RequestContent = {};
RequestContent.Limit = 100;
RequestContent.Offset = 0;

ApiClient->Group.GetGroupJoinRequests(GroupId, RequestContent, THandler<FAccelByteModelsGetMemberRequestsListResponse>::CreateLambda([](const FAccelByteModelsGetMemberRequestsListResponse& Result)
{
    // Do something if GetGroupJoinRequests succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetGroupJoinRequests fails
}));

Unity V1

string groupId = "YourGroupId";
int limit = 100;
int offset = 0;

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetGroupJoinRequests(groupId, limit, offset, result =>
{
    if (result.IsError)
    {
        // Do something if GetGroupJoinRequests fails
        Debug.Log($"Error GetGroupJoinRequests, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetGroupJoinRequests succeeds
});

Unreal Engine V2

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString GroupId = "YourGroupId";

FAccelByteModelsLimitOffsetRequest RequestContent = {};
RequestContent.Limit = 100;
RequestContent.Offset = 0;

ApiClient->Group.GetGroupJoinRequestList(GroupId, RequestContent, THandler<FAccelByteModelsGetMemberRequestsListResponse>::CreateLambda([](const FAccelByteModelsGetMemberRequestsListResponse& Result)
{
    // Do something if GetGroupJoinRequestList succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetGroupJoinRequestList fails
}));

Unity V2

string groupId = "YourGroupId";
int limit = 100;
int offset = 0;

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetGroupJoinRequestsV2(groupId, limit, offset, result =>
{
    if (result.IsError)
    {
        // Do something if GetGroupJoinRequestsV2 fails
        Debug.Log($"Error GetGroupJoinRequestsV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetGroupJoinRequestsV2 succeeds
});

C# Extend SDK

string groupId = "<group-id>";

var response = sdk.Group.MemberRequest.GetGroupJoinRequestPublicV2Op
    .SetOffset(0)
    .SetLimit(100)
    .Execute(groupId, sdk.Namespace);
if (response != null)
{
    //do something when success
}

Go Extend SDK

memberRequestService := &group.MemberRequestService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
groupId := "mygroupid"
namespace := "mygame"
limit := int64(100)
offset := int64(0)
input := &member_request.GetGroupJoinRequestPublicV2Params{
    GroupID:   groupId,
    Namespace: namespace,
    Limit:     &limit,
    Offset:    &offset,
}
result, err := memberRequestService.GetGroupJoinRequestPublicV2Short(input)

Java Extend SDK

final MemberRequest memberRequestWrapper = new MemberRequest(sdk);
String groupId = "YourGroupId";
int limit = 100;
int offset = 0;
ModelsGetMemberRequestsListResponseV1 response;
try {
    response = memberRequestWrapper.getGroupJoinRequestPublicV2(GetGroupJoinRequestPublicV2.builder()
            .namespace("<namespace>")
            .groupId(groupId)
            .limit(limit)
            .offset(offset)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.get_group_join_request_public_v2(
    group_id="GroupId",
    limit=100,
    offset=0,
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループメンバー参加リクエストを受け入れる

参加リクエストのリストを取得した後、グループ管理者はそれらをグループに受け入れることができます。

Unreal Engine V1

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString UserId = "YourUserId";

ApiClient->Group.AcceptGroupJoinRequest(UserId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if AcceptGroupJoinRequest succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if AcceptGroupJoinRequest fails
}));

Unity V1

string userId = "YourUserId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().AcceptOtherJoinRequest(userId, result =>
{
    if (result.IsError)
    {
        // Do something if AcceptOtherJoinRequest fails
        Debug.Log($"Error AcceptOtherJoinRequest, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if AcceptOtherJoinRequest succeeds
});

Unreal Engine V2

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString UserId = "YourUserId";
FString GroupId = "YourGroupId";

ApiClient->Group.AcceptV2GroupJoinRequest(UserId, GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if AcceptV2GroupJoinRequest succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if AcceptV2GroupJoinRequest fails
}));

Unity V2

string userId = "YourUserId";
string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().AcceptOtherJoinRequestV2(userId, groupId, result =>
{
    if (result.IsError)
    {
        // Do something if AcceptOtherJoinRequestV2 fails
        Debug.Log($"Error AcceptOtherJoinRequestV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if AcceptOtherJoinRequestV2 succeeds
});

C# Extend SDK

string groupId = "<group-id>";
string userId = "<user-id>";

var response = sdk.Group.GroupMember.AcceptGroupJoinRequestPublicV2Op
    .Execute(groupId, sdk.Namespace, userId);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupMemberService := &group.GroupMemberService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
groupId := "mygroupid"
namespace := "mygame"
userId := "myuserid"
input := &group_member.AcceptGroupJoinRequestPublicV2Params{
    GroupID:   groupId,
    Namespace: namespace,
    UserID:    userId,
}
result, err := groupMemberService.AcceptGroupJoinRequestPublicV2Short(input)

Java Extend SDK

final GroupMember groupMemberWrapper = new GroupMember(sdk);
String userId = "YourUserId";
String groupId = "YourGroupId";
ModelsMemberRequestGroupResponseV1 response;
try {
    response = groupMemberWrapper.acceptGroupJoinRequestPublicV2(AcceptGroupJoinRequestPublicV2.builder()
            .namespace("<namespace>")
            .groupId(groupId)
            .userId(userId)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.accept_group_join_request_public_v2(
    group_id="GroupId",
    user_id="********************************",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

グループメンバー参加リクエストを拒否する

グループ管理者は、任意のメンバー参加リクエストを拒否できます。

Unreal Engine V1

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString UserId = "YourUserId";

ApiClient->Group.RejectGroupJoinRequest(UserId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if RejectGroupJoinRequest succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if RejectGroupJoinRequest fails
}));

Unity V1

string userId = "YourUserId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().RejectOtherJoinRequest(userId, result =>
{
    if (result.IsError)
    {
        // Do something if RejectOtherJoinRequest fails
        Debug.Log($"Error RejectOtherJoinRequest, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if RejectOtherJoinRequest succeeds
});

Unreal Engine V2

FApiClientPtr ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();

FString UserId = "YourUserId";
FString GroupId = "YourGroupId";

ApiClient->Group.RejectV2GroupJoinRequest(UserId, GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if RejectV2GroupJoinRequest succeeds
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if RejectV2GroupJoinRequest fails
}));

Unity V2

string userId = "YourUserId";
string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().RejectOtherJoinRequestV2(userId, groupId, result =>
{
    if (result.IsError)
    {
        // Do something if RejectOtherJoinRequestV2 fails
        Debug.Log($"Error RejectOtherJoinRequestV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if RejectOtherJoinRequestV2 succeeds
});

C# Extend SDK

string groupId = "<group-id>";
string userId = "<user-id>";

var response = sdk.Group.GroupMember.RejectGroupJoinRequestPublicV2Op
    .Execute(groupId, sdk.Namespace, userId);
if (response != null)
{
    //do something when success
}

Go Extend SDK

groupMemberService := &group.GroupMemberService{
    Client:          factory.NewGroupClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}
groupId := "mygroupid"
namespace := "mygame"
userId := "myuserid"
input := &group_member.RejectGroupJoinRequestPublicV2Params{
    GroupID:   groupId,
    Namespace: namespace,
    UserID:    userId,
}
result, err := groupMemberService.RejectGroupJoinRequestPublicV2Short(input)

Java Extend SDK

final GroupMember groupMemberWrapper = new GroupMember(sdk);
String userId = "YourUserId";
String groupId = "YourGroupId";
ModelsMemberRequestGroupResponseV1 response;
try {
    response = groupMemberWrapper.rejectGroupJoinRequestPublicV2(RejectGroupJoinRequestPublicV2.builder()
            .namespace("<namespace>")
            .groupId(groupId)
            .userId(userId)
            .build());
} catch (Exception e) {
    // Do something if there is an error
    return;
}

Python Extend SDK

import accelbyte_py_sdk.api.group as group_service

result, error = group_service.reject_group_join_request_public_v2(
    group_id="GroupId",
    user_id="********************************",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)