NAV Navbar
Python Java GS2-Formation
 

GS2-Chat

テキストベースのチャット機能を提供します。

メッセージデータはルームごとに管理され、過去24時間分のログが保持されます。 ルームにはパスワードを設定でき、設定した場合はメッセージの取得や投稿リクエストにパスワードが必要となります。 ルームにはユーザIDのホワイトリストを設定でき、設定した場合はホワイトリストに含まれるゲームプレイヤーにしかメッセージの取得や投稿ができなくなります。

メッセージにはカテゴリを設定でき、クライアント側でペイロードのパース方法を切り替えることができます。 たとえば、カテゴリ0 はテキストがペイロードにそのまま含まれる。カテゴリ1 はペイロードにスタンプのIDが含まれる。といった使い方ができます。

ルームを購読すれば、ルームに対して新しい投稿があったときにサーバからプッシュ通知を受け取ることができます。 このとき、通知を受けたいカテゴリを設定できますので、メッセージの種類や重要度別にカテゴリを分ければ、ゲームプレイヤーが通知を受け取るメッセージの種類を設定できるようになりユーザ体験を向上させることができます。 また、購読の設定には モバイルプッシュ通知に転送するか という設定もありますので、うまく活用してください。

GS2-Chat のデータ構造は以下です。

モデル

Namespace

ネームスペース

ネームスペース内に作成できるルームの数や購読の数に制限はありません。 ネームスペースを分割することで生じるデメリットは特にありません。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
description string false ネームスペースの説明
allowCreateRoom boolean true ゲームプレイヤーによるルームの作成を許可するか
postMessageScript ScriptSetting false メッセージを投稿したときに実行するスクリプト
createRoomScript ScriptSetting false ルームを作成したときに実行するスクリプト
deleteRoomScript ScriptSetting false ルームを削除したときに実行するスクリプト
subscribeRoomScript ScriptSetting false ルームを購読したときに実行するスクリプト
unsubscribeRoomScript ScriptSetting false ルームの購読を解除したときに実行するスクリプト
postNotification NotificationSetting false 購読しているルームに新しい投稿がきたときのプッシュ通知
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

Room

ルーム

メッセージのタイムラインを保持する単位です。 ルームにパスワードを設定することで、メッセージの投稿や取得時にパスワードを要求するようになります。 ルームにはユーザIDのホワイトリストを設定でき、設定した場合はホワイトリストに含まれるゲームプレイヤー以外は投稿や取得ができなくなります。

パラメータ データ型 必須 説明
roomId string true ルーム
name string true ルーム名
userId string false ルームを作成したユーザID
metadata string false メタデータ
password string false メッセージを投稿するために必要となるパスワード
whiteListUserIds list[string] false ルームに参加可能なユーザIDリスト
createdAt long true 作成日時
updatedAt long true 最終更新日時

Message

メッセージ

ルームに投稿するデータです。 カテゴリを設定できますので、カテゴリによってペイロードのパース方法を切り替えたり、投稿の通知を送るかを分岐できます。

パラメータ データ型 必須 説明
messageId string true メッセージ
roomName string true ルーム名
name string true メッセージ名
userId string true 発言したユーザID
category integer true メッセージの種類を分類したい時の種類番号
metadata string true メタデータ
createdAt long true 作成日時

Subscribe

購読

ルームに対する新着投稿をプッシュ通知で知らせてほしいときに設定します。

パラメータ データ型 必須 説明
subscribeId string true 購読
userId string true 購読するユーザID
roomName string true 購読するルーム名
notificationTypes list[NotificationType] false 新着メッセージ通知を受け取るカテゴリリスト
createdAt long true 作成日時

ResponseCache

レスポンスキャッシュ

パラメータ データ型 必須 説明
region string false
ownerId string true オーナーID
responseCacheId string true レスポンスキャッシュ のGRN
requestHash string false
result string true APIの応答内容

NotificationType

フォローしているユーザー

パラメータ データ型 必須 説明
category integer true 新着メッセージ通知を受け取るカテゴリ
enableTransferMobilePushNotification boolean true オフラインだった時にモバイルプッシュ通知に転送するか

ScriptSetting

スクリプト設定

パラメータ データ型 必須 説明
triggerScriptId string false 実行前に使用する GS2-Script のスクリプト のGRN
doneTriggerScriptId string false 完了時に使用する GS2-Script のスクリプト のGRN
doneTriggerQueueNamespaceId string false 完了時に使用する GS2-JobQueue のネームスペース のGRN

NotificationSetting

プッシュ通知設定

パラメータ データ型 必須 説明
gatewayNamespaceId string false プッシュ通知に使用する GS2-Gateway のネームスペース のGRN
enableTransferMobileNotification boolean false モバイルプッシュ通知へ転送するか
sound string false モバイルプッシュ通知で使用するサウンドファイル名

LogSetting

ロギング通知設定

パラメータ データ型 必須 説明
loggingNamespaceId string false ログの記録に使用する GS2-Log のネームスペース のGRN

初期化処理

HTTPプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_chat_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2ChatRestClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.chat.rest.Gs2ChatRestClient

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)
session.connect()
Gs2ChatRestClient client = new Gs2ChatRestClient(session)
初期化処理は不要です

HTTPプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_chat_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2ChatRestClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.chat.rest.Gs2ChatRestClient

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect_async(
    (result) => {
        Gs2ChatRestClient client = new Gs2ChatRestClient(session)
    }
)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_chat_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2ChatWebSocketClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.chat.webSocket.Gs2ChatWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect()
Gs2ChatWebSocketClient client = new Gs2ChatWebSocketClient(session)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_chat_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2ChatWebSocketClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.chat.webSocket.Gs2ChatWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect_async(
    (result) => {
        Gs2ChatWebSocketClient client = new Gs2ChatWebSocketClient(session)
    }
)
初期化処理は不要です

GS2-Chat は HTTPプロトコル と WebSocketプロトコル の2種類のプロトコルをサポートしています。

HTTPプロトコル と WebSocketプロトコル の違いは以下に示すとおりです。

HTTP WebSocket
接続方式 都度接続 常時接続
応答性能 優れている
API制限 なし 大容量のデータをやりとりするAPIには使用不可(主にマスターデータ系処理)
利用料金 WebSocketと同一 HTTPと同一

終了処理

HTTPプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

WebSocketプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

session オブジェクトの切断処理を行って終了処理を行います。 同一 session オブジェクトを複数の異なる Client オブジェクトに渡すことができます。

メソッド

createNamespace

同期処理

from gs2_chat_client.request import CreateNamespaceRequest
from gs2_chat_client.result import CreateNamespaceResult

result = client.create_namespace(
    CreateNamespaceRequest()\
        .with_name('namespace-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.CreateNamespaceRequest
import io.gs2.chat.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespace-0001")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import CreateNamespaceRequest
from gs2_chat_client.result import CreateNamespaceResult

def callback(async_result: AsyncResult[CreateNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_namespace_async(
    CreateNamespaceRequest()\
        .with_name('namespace-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.chat.request.CreateNamespaceRequest
import io.gs2.chat.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespace-0001")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Chat::Namespace
Properties:
  Name: String
  Description: Optional[String]
  AllowCreateRoom: Bool
  PostMessageScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  CreateRoomScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  DeleteRoomScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  SubscribeRoomScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  UnsubscribeRoomScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  PostNotification:
    GatewayNamespaceId: Optional[String]
    EnableTransferMobileNotification: Optional[Bool]
    Sound: Optional[String]
  LogSetting:
    LoggingNamespaceId: Optional[String]

ネームスペースを新規作成

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false ネームスペースの説明
allowCreateRoom boolean true ゲームプレイヤーによるルームの作成を許可するか
postMessageScript ScriptSetting false メッセージを投稿したときに実行するスクリプト
createRoomScript ScriptSetting false ルームを作成したときに実行するスクリプト
deleteRoomScript ScriptSetting false ルームを削除したときに実行するスクリプト
subscribeRoomScript ScriptSetting false ルームを購読したときに実行するスクリプト
unsubscribeRoomScript ScriptSetting false ルームの購読を解除したときに実行するスクリプト
postNotification NotificationSetting false 購読しているルームに新しい投稿がきたときのプッシュ通知
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

createRoom

同期処理

from gs2_chat_client.request import CreateRoomRequest
from gs2_chat_client.result import CreateRoomResult

result = client.create_room(
    CreateRoomRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.CreateRoomRequest
import io.gs2.chat.result.CreateRoomResult

result = client.createRoom(
    CreateRoomRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import CreateRoomRequest
from gs2_chat_client.result import CreateRoomResult

def callback(async_result: AsyncResult[CreateRoomResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_room_async(
    CreateRoomRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.chat.request.CreateRoomRequest
import io.gs2.chat.result.CreateRoomResult

result = client.createRoom(
    CreateRoomRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Chat::Room
Properties:
  NamespaceName: String
  Metadata: Optional[String]
  Password: Optional[String]
  WhiteListUserIds:
    - String
    - String

ルームを作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
metadata string false メタデータ
password string false メッセージを投稿するために必要となるパスワード
whiteListUserIds list[string] false ルームに参加可能なユーザIDリスト
パラメータ データ型 説明
item Room 作成したルーム

createRoomFromBackend

同期処理

from gs2_chat_client.request import CreateRoomFromBackendRequest
from gs2_chat_client.result import CreateRoomFromBackendResult

result = client.create_room_from_backend(
    CreateRoomFromBackendRequest()\
        .with_namespace_name('namespace-0001')\
        .with_metadata('ROOM_0002')\
        .with_password('password-0002')\
        .with_white_list_user_ids([
'user-0001',    
'user-0002',    
'user-0003'
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.CreateRoomFromBackendRequest
import io.gs2.chat.result.CreateRoomFromBackendResult

result = client.createRoomFromBackend(
    CreateRoomFromBackendRequest()
        .withNamespaceName("namespace-0001")
        .withMetadata("ROOM_0002")
        .withPassword("password-0002")
        .withWhiteListUserIds(new [] {
"user-0001",    
"user-0002",    
"user-0003"
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import CreateRoomFromBackendRequest
from gs2_chat_client.result import CreateRoomFromBackendResult

def callback(async_result: AsyncResult[CreateRoomFromBackendResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_room_from_backend_async(
    CreateRoomFromBackendRequest()\
        .with_namespace_name('namespace-0001')\
        .with_metadata('ROOM_0002')\
        .with_password('password-0002')\
        .with_white_list_user_ids([
'user-0001',    
'user-0002',    
'user-0003'
]),
    callback
)
import io.gs2.chat.request.CreateRoomFromBackendRequest
import io.gs2.chat.result.CreateRoomFromBackendResult

result = client.createRoomFromBackend(
    CreateRoomFromBackendRequest()
        .withNamespaceName("namespace-0001")
        .withMetadata("ROOM_0002")
        .withPassword("password-0002")
        .withWhiteListUserIds(new [] {
"user-0001",    
"user-0002",    
"user-0003"
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Chat::Room
Properties:
  NamespaceName: String
  UserId: Optional[String]
  Metadata: Optional[String]
  Password: Optional[String]
  WhiteListUserIds:
    - String
    - String

ルームを作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザID
metadata string false メタデータ
password string false メッセージを投稿するために必要となるパスワード
whiteListUserIds list[string] false ルームに参加可能なユーザIDリスト
パラメータ データ型 説明
item Room 作成したルーム

deleteMessage

同期処理

from gs2_chat_client.request import DeleteMessageRequest
from gs2_chat_client.result import DeleteMessageResult

result = client.delete_message(
    DeleteMessageRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_message_name('message-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.DeleteMessageRequest
import io.gs2.chat.result.DeleteMessageResult

result = client.deleteMessage(
    DeleteMessageRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withMessageName("message-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import DeleteMessageRequest
from gs2_chat_client.result import DeleteMessageResult

def callback(async_result: AsyncResult[DeleteMessageResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_message_async(
    DeleteMessageRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_message_name('message-0001'),
    callback
)
import io.gs2.chat.request.DeleteMessageRequest
import io.gs2.chat.result.DeleteMessageResult

result = client.deleteMessage(
    DeleteMessageRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withMessageName("message-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

メッセージを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
messageName string true メッセージ名
パラメータ データ型 説明
item Message 削除したメッセージ

deleteNamespace

同期処理

from gs2_chat_client.request import DeleteNamespaceRequest
from gs2_chat_client.result import DeleteNamespaceResult

result = client.delete_namespace(
    DeleteNamespaceRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.DeleteNamespaceRequest
import io.gs2.chat.result.DeleteNamespaceResult

result = client.deleteNamespace(
    DeleteNamespaceRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import DeleteNamespaceRequest
from gs2_chat_client.result import DeleteNamespaceResult

def callback(async_result: AsyncResult[DeleteNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_namespace_async(
    DeleteNamespaceRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.chat.request.DeleteNamespaceRequest
import io.gs2.chat.result.DeleteNamespaceResult

result = client.deleteNamespace(
    DeleteNamespaceRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Namespace 削除したネームスペース

deleteRoom

同期処理

from gs2_chat_client.request import DeleteRoomRequest
from gs2_chat_client.result import DeleteRoomResult

result = client.delete_room(
    DeleteRoomRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name('room-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.DeleteRoomRequest
import io.gs2.chat.result.DeleteRoomResult

result = client.deleteRoom(
    DeleteRoomRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName("room-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import DeleteRoomRequest
from gs2_chat_client.result import DeleteRoomResult

def callback(async_result: AsyncResult[DeleteRoomResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_room_async(
    DeleteRoomRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name('room-0001'),
    callback
)
import io.gs2.chat.request.DeleteRoomRequest
import io.gs2.chat.result.DeleteRoomResult

result = client.deleteRoom(
    DeleteRoomRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName("room-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ルームを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
パラメータ データ型 説明
item Room 削除したルーム

deleteRoomFromBackend

同期処理

from gs2_chat_client.request import DeleteRoomFromBackendRequest
from gs2_chat_client.result import DeleteRoomFromBackendResult

result = client.delete_room_from_backend(
    DeleteRoomFromBackendRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name('room-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.DeleteRoomFromBackendRequest
import io.gs2.chat.result.DeleteRoomFromBackendResult

result = client.deleteRoomFromBackend(
    DeleteRoomFromBackendRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName("room-0002")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import DeleteRoomFromBackendRequest
from gs2_chat_client.result import DeleteRoomFromBackendResult

def callback(async_result: AsyncResult[DeleteRoomFromBackendResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_room_from_backend_async(
    DeleteRoomFromBackendRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name('room-0002'),
    callback
)
import io.gs2.chat.request.DeleteRoomFromBackendRequest
import io.gs2.chat.result.DeleteRoomFromBackendResult

result = client.deleteRoomFromBackend(
    DeleteRoomFromBackendRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName("room-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ルームを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
userId string false ユーザID
パラメータ データ型 説明
item Room 削除したルーム

describeMessages

同期処理

from gs2_chat_client.request import DescribeMessagesRequest
from gs2_chat_client.result import DescribeMessagesResult

result = client.describe_messages(
    DescribeMessagesRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.DescribeMessagesRequest
import io.gs2.chat.result.DescribeMessagesResult

result = client.describeMessages(
    DescribeMessagesRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import DescribeMessagesRequest
from gs2_chat_client.result import DescribeMessagesResult

def callback(async_result: AsyncResult[DescribeMessagesResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_messages_async(
    DescribeMessagesRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name']),
    callback
)
import io.gs2.chat.request.DescribeMessagesRequest
import io.gs2.chat.result.DescribeMessagesResult

result = client.describeMessages(
    DescribeMessagesRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

メッセージの一覧取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
password string false メッセージを投稿するために必要となるパスワード
startAt long false メッセージの取得を開始する時間
limit long false データの取得件数
パラメータ データ型 説明
items list[Message] メッセージのリスト

describeNamespaces

同期処理

from gs2_chat_client.request import DescribeNamespacesRequest
from gs2_chat_client.result import DescribeNamespacesResult

result = client.describe_namespaces(
    DescribeNamespacesRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.DescribeNamespacesRequest
import io.gs2.chat.result.DescribeNamespacesResult

result = client.describeNamespaces(
    DescribeNamespacesRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import DescribeNamespacesRequest
from gs2_chat_client.result import DescribeNamespacesResult

def callback(async_result: AsyncResult[DescribeNamespacesResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_namespaces_async(
    DescribeNamespacesRequest()\
    callback
)
import io.gs2.chat.request.DescribeNamespacesRequest
import io.gs2.chat.result.DescribeNamespacesResult

result = client.describeNamespaces(
    DescribeNamespacesRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースの一覧を取得

パラメータ データ型 必須 説明
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Namespace] ネームスペースのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeRooms

同期処理

from gs2_chat_client.request import DescribeRoomsRequest
from gs2_chat_client.result import DescribeRoomsResult

result = client.describe_rooms(
    DescribeRoomsRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.DescribeRoomsRequest
import io.gs2.chat.result.DescribeRoomsResult

result = client.describeRooms(
    DescribeRoomsRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import DescribeRoomsRequest
from gs2_chat_client.result import DescribeRoomsResult

def callback(async_result: AsyncResult[DescribeRoomsResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_rooms_async(
    DescribeRoomsRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.chat.request.DescribeRoomsRequest
import io.gs2.chat.result.DescribeRoomsResult

result = client.describeRooms(
    DescribeRoomsRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ルームの一覧取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Room] ルームのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeSubscribes

同期処理

from gs2_chat_client.request import DescribeSubscribesRequest
from gs2_chat_client.result import DescribeSubscribesResult

result = client.describe_subscribes(
    DescribeSubscribesRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.DescribeSubscribesRequest
import io.gs2.chat.result.DescribeSubscribesResult

result = client.describeSubscribes(
    DescribeSubscribesRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import DescribeSubscribesRequest
from gs2_chat_client.result import DescribeSubscribesResult

def callback(async_result: AsyncResult[DescribeSubscribesResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_subscribes_async(
    DescribeSubscribesRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.chat.request.DescribeSubscribesRequest
import io.gs2.chat.result.DescribeSubscribesResult

result = client.describeSubscribes(
    DescribeSubscribesRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

購読しているルームの一覧取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Subscribe] 購読のリスト
nextPageToken string リストの続きを取得するためのページトークン

describeSubscribesByRoomName

同期処理

from gs2_chat_client.request import DescribeSubscribesByRoomNameRequest
from gs2_chat_client.result import DescribeSubscribesByRoomNameResult

result = client.describe_subscribes_by_room_name(
    DescribeSubscribesByRoomNameRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.DescribeSubscribesByRoomNameRequest
import io.gs2.chat.result.DescribeSubscribesByRoomNameResult

result = client.describeSubscribesByRoomName(
    DescribeSubscribesByRoomNameRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import DescribeSubscribesByRoomNameRequest
from gs2_chat_client.result import DescribeSubscribesByRoomNameResult

def callback(async_result: AsyncResult[DescribeSubscribesByRoomNameResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_subscribes_by_room_name_async(
    DescribeSubscribesByRoomNameRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name']),
    callback
)
import io.gs2.chat.request.DescribeSubscribesByRoomNameRequest
import io.gs2.chat.result.DescribeSubscribesByRoomNameResult

result = client.describeSubscribesByRoomName(
    DescribeSubscribesByRoomNameRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ルーム名を指定して購読しているユーザの一覧取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true 購読するユーザID
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Subscribe] 購読のリスト
nextPageToken string リストの続きを取得するためのページトークン

describeSubscribesByUserId

同期処理

from gs2_chat_client.request import DescribeSubscribesByUserIdRequest
from gs2_chat_client.result import DescribeSubscribesByUserIdResult

result = client.describe_subscribes_by_user_id(
    DescribeSubscribesByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.DescribeSubscribesByUserIdRequest
import io.gs2.chat.result.DescribeSubscribesByUserIdResult

result = client.describeSubscribesByUserId(
    DescribeSubscribesByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import DescribeSubscribesByUserIdRequest
from gs2_chat_client.result import DescribeSubscribesByUserIdResult

def callback(async_result: AsyncResult[DescribeSubscribesByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_subscribes_by_user_id_async(
    DescribeSubscribesByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.chat.request.DescribeSubscribesByUserIdRequest
import io.gs2.chat.result.DescribeSubscribesByUserIdResult

result = client.describeSubscribesByUserId(
    DescribeSubscribesByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定して購読しているルームの一覧取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true 購読するユーザID
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Subscribe] 購読のリスト
nextPageToken string リストの続きを取得するためのページトークン

getMessage

同期処理

from gs2_chat_client.request import GetMessageRequest
from gs2_chat_client.result import GetMessageResult

result = client.get_message(
    GetMessageRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_message_name('message-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.GetMessageRequest
import io.gs2.chat.result.GetMessageResult

result = client.getMessage(
    GetMessageRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withMessageName("message-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import GetMessageRequest
from gs2_chat_client.result import GetMessageResult

def callback(async_result: AsyncResult[GetMessageResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_message_async(
    GetMessageRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_message_name('message-0001'),
    callback
)
import io.gs2.chat.request.GetMessageRequest
import io.gs2.chat.result.GetMessageResult

result = client.getMessage(
    GetMessageRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withMessageName("message-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

メッセージを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
messageName string true メッセージ名
パラメータ データ型 説明
item Message メッセージ

getNamespace

同期処理

from gs2_chat_client.request import GetNamespaceRequest
from gs2_chat_client.result import GetNamespaceResult

result = client.get_namespace(
    GetNamespaceRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.GetNamespaceRequest
import io.gs2.chat.result.GetNamespaceResult

result = client.getNamespace(
    GetNamespaceRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import GetNamespaceRequest
from gs2_chat_client.result import GetNamespaceResult

def callback(async_result: AsyncResult[GetNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_namespace_async(
    GetNamespaceRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.chat.request.GetNamespaceRequest
import io.gs2.chat.result.GetNamespaceResult

result = client.getNamespace(
    GetNamespaceRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Namespace ネームスペース

getNamespaceStatus

同期処理

from gs2_chat_client.request import GetNamespaceStatusRequest
from gs2_chat_client.result import GetNamespaceStatusResult

result = client.get_namespace_status(
    GetNamespaceStatusRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.GetNamespaceStatusRequest
import io.gs2.chat.result.GetNamespaceStatusResult

result = client.getNamespaceStatus(
    GetNamespaceStatusRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import GetNamespaceStatusRequest
from gs2_chat_client.result import GetNamespaceStatusResult

def callback(async_result: AsyncResult[GetNamespaceStatusResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_namespace_status_async(
    GetNamespaceStatusRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.chat.request.GetNamespaceStatusRequest
import io.gs2.chat.result.GetNamespaceStatusResult

result = client.getNamespaceStatus(
    GetNamespaceStatusRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
status string

getRoom

同期処理

from gs2_chat_client.request import GetRoomRequest
from gs2_chat_client.result import GetRoomResult

result = client.get_room(
    GetRoomRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name('room-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.GetRoomRequest
import io.gs2.chat.result.GetRoomResult

result = client.getRoom(
    GetRoomRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName("room-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import GetRoomRequest
from gs2_chat_client.result import GetRoomResult

def callback(async_result: AsyncResult[GetRoomResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_room_async(
    GetRoomRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name('room-0001'),
    callback
)
import io.gs2.chat.request.GetRoomRequest
import io.gs2.chat.result.GetRoomResult

result = client.getRoom(
    GetRoomRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName("room-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ルームを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
パラメータ データ型 説明
item Room ルーム

getSubscribe

同期処理

from gs2_chat_client.request import GetSubscribeRequest
from gs2_chat_client.result import GetSubscribeResult

result = client.get_subscribe(
    GetSubscribeRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.GetSubscribeRequest
import io.gs2.chat.result.GetSubscribeResult

result = client.getSubscribe(
    GetSubscribeRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import GetSubscribeRequest
from gs2_chat_client.result import GetSubscribeResult

def callback(async_result: AsyncResult[GetSubscribeResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_subscribe_async(
    GetSubscribeRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name']),
    callback
)
import io.gs2.chat.request.GetSubscribeRequest
import io.gs2.chat.result.GetSubscribeResult

result = client.getSubscribe(
    GetSubscribeRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

購読を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
パラメータ データ型 説明
item Subscribe 購読

getSubscribeByUserId

同期処理

from gs2_chat_client.request import GetSubscribeByUserIdRequest
from gs2_chat_client.result import GetSubscribeByUserIdResult

result = client.get_subscribe_by_user_id(
    GetSubscribeByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.GetSubscribeByUserIdRequest
import io.gs2.chat.result.GetSubscribeByUserIdResult

result = client.getSubscribeByUserId(
    GetSubscribeByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withUserId("user-0002")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import GetSubscribeByUserIdRequest
from gs2_chat_client.result import GetSubscribeByUserIdResult

def callback(async_result: AsyncResult[GetSubscribeByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_subscribe_by_user_id_async(
    GetSubscribeByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_user_id('user-0002'),
    callback
)
import io.gs2.chat.request.GetSubscribeByUserIdRequest
import io.gs2.chat.result.GetSubscribeByUserIdResult

result = client.getSubscribeByUserId(
    GetSubscribeByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withUserId("user-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定して購読を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
userId string true 購読するユーザID
パラメータ データ型 説明
item Subscribe 購読

post

同期処理

from gs2_chat_client.request import PostRequest
from gs2_chat_client.result import PostResult

result = client.post(
    PostRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_metadata('MESSAGE_0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.PostRequest
import io.gs2.chat.result.PostResult

result = client.post(
    PostRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withMetadata("MESSAGE_0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import PostRequest
from gs2_chat_client.result import PostResult

def callback(async_result: AsyncResult[PostResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.post_async(
    PostRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_metadata('MESSAGE_0001'),
    callback
)
import io.gs2.chat.request.PostRequest
import io.gs2.chat.result.PostResult

result = client.post(
    PostRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withMetadata("MESSAGE_0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

メッセージを投稿

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
category integer true メッセージの種類を分類したい時の種類番号
metadata string true メタデータ
password string false メッセージを投稿するために必要となるパスワード
パラメータ データ型 説明
item Message 投稿したメッセージ

postByUserId

同期処理

from gs2_chat_client.request import PostByUserIdRequest
from gs2_chat_client.result import PostByUserIdResult

result = client.post_by_user_id(
    PostByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_user_id('user-0001')\
        .with_category(1)\
        .with_metadata('MESSAGE_0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.PostByUserIdRequest
import io.gs2.chat.result.PostByUserIdResult

result = client.postByUserId(
    PostByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withUserId("user-0001")
        .withCategory(1)
        .withMetadata("MESSAGE_0002")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import PostByUserIdRequest
from gs2_chat_client.result import PostByUserIdResult

def callback(async_result: AsyncResult[PostByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.post_by_user_id_async(
    PostByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_user_id('user-0001')\
        .with_category(1)\
        .with_metadata('MESSAGE_0002'),
    callback
)
import io.gs2.chat.request.PostByUserIdRequest
import io.gs2.chat.result.PostByUserIdResult

result = client.postByUserId(
    PostByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withUserId("user-0001")
        .withCategory(1)
        .withMetadata("MESSAGE_0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してメッセージを投稿

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
userId string true 発言したユーザID
category integer true メッセージの種類を分類したい時の種類番号
metadata string true メタデータ
password string false メッセージを投稿するために必要となるパスワード
パラメータ データ型 説明
item Message 投稿したメッセージ

subscribe

同期処理

from gs2_chat_client.request import SubscribeRequest
from gs2_chat_client.result import SubscribeResult

result = client.subscribe(
    SubscribeRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_notification_types([
Object("NotificationType", {})
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.SubscribeRequest
import io.gs2.chat.result.SubscribeResult

result = client.subscribe(
    SubscribeRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withNotificationTypes(new [] {
Object("NotificationType", {})
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import SubscribeRequest
from gs2_chat_client.result import SubscribeResult

def callback(async_result: AsyncResult[SubscribeResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.subscribe_async(
    SubscribeRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_notification_types([
Object("NotificationType", {})
]),
    callback
)
import io.gs2.chat.request.SubscribeRequest
import io.gs2.chat.result.SubscribeResult

result = client.subscribe(
    SubscribeRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withNotificationTypes(new [] {
Object("NotificationType", {})
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ルームを購読

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
notificationTypes list[NotificationType] false 新着メッセージ通知を受け取るカテゴリリスト
パラメータ データ型 説明
item Subscribe 購読した購読

subscribeByUserId

同期処理

from gs2_chat_client.request import SubscribeByUserIdRequest
from gs2_chat_client.result import SubscribeByUserIdResult

result = client.subscribe_by_user_id(
    SubscribeByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_user_id('user-0002')\
        .with_notification_types([
Object("NotificationType", {"category": 1, "enableTransferMobilePushNotification": True})
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.SubscribeByUserIdRequest
import io.gs2.chat.result.SubscribeByUserIdResult

result = client.subscribeByUserId(
    SubscribeByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withUserId("user-0002")
        .withNotificationTypes(new [] {
Object("NotificationType", {"category": 1, "enableTransferMobilePushNotification": true})
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import SubscribeByUserIdRequest
from gs2_chat_client.result import SubscribeByUserIdResult

def callback(async_result: AsyncResult[SubscribeByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.subscribe_by_user_id_async(
    SubscribeByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_user_id('user-0002')\
        .with_notification_types([
Object("NotificationType", {"category": 1, "enableTransferMobilePushNotification": True})
]),
    callback
)
import io.gs2.chat.request.SubscribeByUserIdRequest
import io.gs2.chat.result.SubscribeByUserIdResult

result = client.subscribeByUserId(
    SubscribeByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withUserId("user-0002")
        .withNotificationTypes(new [] {
Object("NotificationType", {"category": 1, "enableTransferMobilePushNotification": true})
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してルームを購読

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
userId string true 購読するユーザID
notificationTypes list[NotificationType] false 新着メッセージ通知を受け取るカテゴリリスト
パラメータ データ型 説明
item Subscribe 購読した購読

unsubscribe

同期処理

from gs2_chat_client.request import UnsubscribeRequest
from gs2_chat_client.result import UnsubscribeResult

result = client.unsubscribe(
    UnsubscribeRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.UnsubscribeRequest
import io.gs2.chat.result.UnsubscribeResult

result = client.unsubscribe(
    UnsubscribeRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import UnsubscribeRequest
from gs2_chat_client.result import UnsubscribeResult

def callback(async_result: AsyncResult[UnsubscribeResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.unsubscribe_async(
    UnsubscribeRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name']),
    callback
)
import io.gs2.chat.request.UnsubscribeRequest
import io.gs2.chat.result.UnsubscribeResult

result = client.unsubscribe(
    UnsubscribeRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

購読の購読を解除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
パラメータ データ型 説明
item Subscribe 解除した購読

unsubscribeByUserId

同期処理

from gs2_chat_client.request import UnsubscribeByUserIdRequest
from gs2_chat_client.result import UnsubscribeByUserIdResult

result = client.unsubscribe_by_user_id(
    UnsubscribeByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.UnsubscribeByUserIdRequest
import io.gs2.chat.result.UnsubscribeByUserIdResult

result = client.unsubscribeByUserId(
    UnsubscribeByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withUserId("user-0002")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import UnsubscribeByUserIdRequest
from gs2_chat_client.result import UnsubscribeByUserIdResult

def callback(async_result: AsyncResult[UnsubscribeByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.unsubscribe_by_user_id_async(
    UnsubscribeByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name(room1['name'])\
        .with_user_id('user-0002'),
    callback
)
import io.gs2.chat.request.UnsubscribeByUserIdRequest
import io.gs2.chat.result.UnsubscribeByUserIdResult

result = client.unsubscribeByUserId(
    UnsubscribeByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName(room1.get'Name())
        .withUserId("user-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定して購読の購読を解除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
userId string true 購読するユーザID
パラメータ データ型 説明
item Subscribe 解除した購読

updateNamespace

同期処理

from gs2_chat_client.request import UpdateNamespaceRequest
from gs2_chat_client.result import UpdateNamespaceResult

result = client.update_namespace(
    UpdateNamespaceRequest()\
        .with_namespace_name('namespace-0001')\
        .with_description('description1')\
        .with_allow_create_room(False)\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.UpdateNamespaceRequest
import io.gs2.chat.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withAllowCreateRoom(false)
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import UpdateNamespaceRequest
from gs2_chat_client.result import UpdateNamespaceResult

def callback(async_result: AsyncResult[UpdateNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_namespace_async(
    UpdateNamespaceRequest()\
        .with_namespace_name('namespace-0001')\
        .with_description('description1')\
        .with_allow_create_room(False)\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.chat.request.UpdateNamespaceRequest
import io.gs2.chat.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withAllowCreateRoom(false)
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
description string false ネームスペースの説明
allowCreateRoom boolean true ゲームプレイヤーによるルームの作成を許可するか
postMessageScript ScriptSetting false メッセージを投稿したときに実行するスクリプト
createRoomScript ScriptSetting false ルームを作成したときに実行するスクリプト
deleteRoomScript ScriptSetting false ルームを削除したときに実行するスクリプト
subscribeRoomScript ScriptSetting false ルームを購読したときに実行するスクリプト
unsubscribeRoomScript ScriptSetting false ルームの購読を解除したときに実行するスクリプト
postNotification NotificationSetting false 購読しているルームに新しい投稿がきたときのプッシュ通知
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

updateNotificationType

同期処理

from gs2_chat_client.request import UpdateNotificationTypeRequest
from gs2_chat_client.result import UpdateNotificationTypeResult

result = client.update_notification_type(
    UpdateNotificationTypeRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.UpdateNotificationTypeRequest
import io.gs2.chat.result.UpdateNotificationTypeResult

result = client.updateNotificationType(
    UpdateNotificationTypeRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import UpdateNotificationTypeRequest
from gs2_chat_client.result import UpdateNotificationTypeResult

def callback(async_result: AsyncResult[UpdateNotificationTypeResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_notification_type_async(
    UpdateNotificationTypeRequest()\
    callback
)
import io.gs2.chat.request.UpdateNotificationTypeRequest
import io.gs2.chat.result.UpdateNotificationTypeResult

result = client.updateNotificationType(
    UpdateNotificationTypeRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

通知方法を更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
notificationTypes list[NotificationType] false 新着メッセージ通知を受け取るカテゴリリスト
パラメータ データ型 説明
item Subscribe 更新した購読

updateNotificationTypeByUserId

同期処理

from gs2_chat_client.request import UpdateNotificationTypeByUserIdRequest
from gs2_chat_client.result import UpdateNotificationTypeByUserIdResult

result = client.update_notification_type_by_user_id(
    UpdateNotificationTypeByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.UpdateNotificationTypeByUserIdRequest
import io.gs2.chat.result.UpdateNotificationTypeByUserIdResult

result = client.updateNotificationTypeByUserId(
    UpdateNotificationTypeByUserIdRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import UpdateNotificationTypeByUserIdRequest
from gs2_chat_client.result import UpdateNotificationTypeByUserIdResult

def callback(async_result: AsyncResult[UpdateNotificationTypeByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_notification_type_by_user_id_async(
    UpdateNotificationTypeByUserIdRequest()\
    callback
)
import io.gs2.chat.request.UpdateNotificationTypeByUserIdRequest
import io.gs2.chat.result.UpdateNotificationTypeByUserIdResult

result = client.updateNotificationTypeByUserId(
    UpdateNotificationTypeByUserIdRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定して通知方法を更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
userId string true 購読するユーザID
notificationTypes list[NotificationType] false 新着メッセージ通知を受け取るカテゴリリスト
パラメータ データ型 説明
item Subscribe 更新した購読

updateRoom

同期処理

from gs2_chat_client.request import UpdateRoomRequest
from gs2_chat_client.result import UpdateRoomResult

result = client.update_room(
    UpdateRoomRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name('room-0001')\
        .with_metadata('ROOM_0001')\
        .with_password('password-0003')\
        .with_white_list_user_ids([
'user-0001',    
'user-0002',    
'user-0003'
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.chat.request.UpdateRoomRequest
import io.gs2.chat.result.UpdateRoomResult

result = client.updateRoom(
    UpdateRoomRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName("room-0001")
        .withMetadata("ROOM_0001")
        .withPassword("password-0003")
        .withWhiteListUserIds(new [] {
"user-0001",    
"user-0002",    
"user-0003"
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_chat_client.request import UpdateRoomRequest
from gs2_chat_client.result import UpdateRoomResult

def callback(async_result: AsyncResult[UpdateRoomResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_room_async(
    UpdateRoomRequest()\
        .with_namespace_name('namespace-0001')\
        .with_room_name('room-0001')\
        .with_metadata('ROOM_0001')\
        .with_password('password-0003')\
        .with_white_list_user_ids([
'user-0001',    
'user-0002',    
'user-0003'
]),
    callback
)
import io.gs2.chat.request.UpdateRoomRequest
import io.gs2.chat.result.UpdateRoomResult

result = client.updateRoom(
    UpdateRoomRequest()
        .withNamespaceName("namespace-0001")
        .withRoomName("room-0001")
        .withMetadata("ROOM_0001")
        .withPassword("password-0003")
        .withWhiteListUserIds(new [] {
"user-0001",    
"user-0002",    
"user-0003"
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ルームを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
roomName string true ルーム名
metadata string false メタデータ
password string false メッセージを投稿するために必要となるパスワード
whiteListUserIds list[string] false ルームに参加可能なユーザIDリスト
パラメータ データ型 説明
item Room 更新したルーム

GS2-Script トリガーイベント

PostMessageTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
room = args['room']  -- type: Room
message = args['message']  -- type: Message

result = {
    permit=  -- type: boolean
}

メッセージ投稿時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
room Room ルーム
message Message メッセージ
パラメータ データ型 説明
permit boolean メッセージ投稿を許可するか

PostMessageDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
room = args['room']  -- type: Room
message = args['message']  -- type: Message

result = {
}

メッセージ投稿完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
room Room ルーム
message Message メッセージ
パラメータ データ型 説明

CreateRoomTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
room = args['room']  -- type: Room

result = {
    permit=  -- type: boolean
}

ルーム作成時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
room Room ルーム
パラメータ データ型 説明
permit boolean ルーム作成を許可するか

CreateRoomDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
room = args['room']  -- type: Room

result = {
}

ルーム作成完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
room Room ルーム
パラメータ データ型 説明

DeleteRoomTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
room = args['room']  -- type: Room

result = {
    permit=  -- type: boolean
}

ルーム削除時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
room Room ルーム
パラメータ データ型 説明
permit boolean ルーム削除を許可するか

DeleteRoomDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
room = args['room']  -- type: Room

result = {
}

ルーム削除完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
room Room ルーム
パラメータ データ型 説明

SubscribeRoomTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
room = args['room']  -- type: Room
subscribe = args['subscribe']  -- type: Subscribe

result = {
    permit=  -- type: boolean
}

ルーム購読時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
room Room ルーム
subscribe Subscribe 購読
パラメータ データ型 説明
permit boolean ルーム購読を許可するか

SubscribeRoomDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
room = args['room']  -- type: Room
subscribe = args['subscribe']  -- type: Subscribe

result = {
}

ルーム購読完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
room Room ルーム
subscribe Subscribe 購読
パラメータ データ型 説明

UnsubscribeRoomTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
room = args['room']  -- type: Room
subscribe = args['subscribe']  -- type: Subscribe

result = {
    permit=  -- type: boolean
}

ルーム購読解除時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
room Room ルーム
subscribe Subscribe 購読
パラメータ データ型 説明
permit boolean ルーム購読解除を許可するか

UnsubscribeRoomDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
room = args['room']  -- type: Room
subscribe = args['subscribe']  -- type: Subscribe

result = {
}

ルーム購読解除完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
room Room ルーム
subscribe Subscribe 購読
パラメータ データ型 説明

マスターデータフォーマット

マスターデータはありません

GS2-Chat の制限・制約

利用いただくにあたって注意いただく制限・制約はありません