Java/Android 클라이언트 가이드 #

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

repositories {
    maven {
        url 'https://jitpack.io'
    }
}

dependencies {
    implementation 'com.github.heroiclabs.nakama-java:nakama-java:<commit>'

 // or, depend on the fat Jar which bundles all of the Nakama Java dependencies into a single Jar.
 // implementation 'com.github.heroiclabs.nakama-java:nakama-java-all:<commit>'
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

  <repositories>
    <repository>
      <id>jitpack.io</id>
      <url>https://jitpack.io</url>
    </repository>
  </repositories>

  ...
  <dependencies>
    <dependency>
      <groupId>com.github.heroiclabs.nakama-java</groupId>
      <artifactId>nakama-java</artifactId>
      <version>_commit_</version>
      <type>jar</type>
    </dependency>
  </dependencies>

1
2
3
4
5
6
7
8

  <dependencies>
    <dependency>
      <groupId>com.github.heroiclabs.nakama-java</groupId>
      <artifactId>nakama-java-all</artifactId>
      <version>_commit_</version>
      <type>jar</type>
    </dependency>
  </dependencies>

1
2

// Where App is the name of your class
Logger logger = LoggerFactory.getLogger(App.class);

1

<uses-permission android:name="android.permission.INTERNET"/>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// Create a single thread executor
ExecutorService executor = Executors.newSingleThreadExecutor();

// Get a ListenableFuture with a Session result
ListenableFuture<Session> authFuture = client.authenticateDevice(deviceId);

// Setup the success and failure callbacks, specifying which executor to use
Futures.addCallback(authFuture, new FutureCallback<Session>() {
    @Override
    public void onSuccess(@NullableDecl Session session) {
        logger.debug("Authenticated user id: " + session.getUserId());
        executor.shutdown();
    }

    @Override
    public void onFailure(Throwable throwable) {
        logger.error(throwable.getMessage());
        executor.shutdown();
    }
}, executor);

// Wait for the executor to finish all tasks
try {
    executor.awaitTermination(5, TimeUnit.SECONDS);
}
catch (InterruptedException e) {
    logger.error(e.getMessage());
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Get a ListenableFuture with a Session result
ListenableFuture<Session> authFuture = client.authenticateDevice(deviceId);

// Create an AsyncFunction to get the Account of a user using a Session object
AsyncFunction<Session, Account> accountFunction = session -> client.getAccount(session);

// Get a ListenableFuture from Futures.transformAsync by first passing the original Future, followed by the extended Future and finally an exector
ListenableFuture<Account> accountFuture = Futures.transformAsync(authFuture, accountFunction, executor);

// Setup the success and failture callbacks as usual
Futures.addCallback(accountFuture, new FutureCallback<>() {
    @Override
    public void onSuccess(@NullableDecl Account account) {
        logger.debug("Got account for user id: " + account.getUser().getId());
        executor.shutdown();
    }

    @Override
    public void onFailure(Throwable throwable) {
        logger.error(throwable.getMessage());
        executor.shutdown();
    }
}, executor);

1

Account account = client.getAccount(session).get();

1
2
3

Map<String, String> data = new HashMap<>();
data.put("Key", "Value");
data.put("AnotherKey", "AnotherValue");

1
2
3
4
5

// Serialize
String serialized = new Gson().toJson(data, data.getClass());

// Deserialize
Map<String, String> deserialized = new Gson().fromJson(serialized, new TypeToken<Map<String, String>>(){}.getType());

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Serialize
String serialized = null;
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

try {
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
    objectOutputStream.writeObject(data);
    byte[] bytes = byteArrayOutputStream.toByteArray();
    serialized = Base64.getEncoder().encodeToString(bytes);
} catch (IOException e) {
    e.printStackTrace();
}


// Deserialize
byte[] bytes = Base64.getDecoder().decode(serialized);
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);

try {
    ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
    Map<String, String> deserialized = (Map<String, String>) objectInputStream.readObject();
} catch (IOException e) {
    e.printStackTrace();
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

1
2
3
4

// explictly passing the defaults
Client client = new DefaultClient("defaultkey", "127.0.0.1", 7349, false)
// or same as above
Client client = new DefaultClient("defaultkey");

1

client.Timeout = 10;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

SocketClient socket = client.createWebSocket();

SocketListener listener = new AbstractSocketListener() {
    @Override
    public void onDisconnect(final Throwable t) {
        logger.info("Socket disconnected.");
    }
};

socket.connect(session, listener).get();
logger.info("Socket connected.");

1
2
3

String deviceId = UUID.randomUUID().toString();
Session session = client.authenticateDevice(deviceId).get();
logger.info("Session authToken: {}", session.getAuthToken());

1
2
3

String oauthToken = "...";
Session session = client.authenticateFacebook(oauthToken).get();
logger.info("Session authToken: {}", session.getAuthToken());

1
2
3

String deviceId = UUID.randomUUID().toString();
client.linkDevice(session, deviceId);
logger.info("Linked device id {} for user {}", deviceId, session.getUserId());

1
2
3
4

String facebookAccessToken = "...";
boolean importFriends = true;
client.linkFacebook(session, facebookAccessToken, importFriends);
logger.info("Linked facebook authentication for user {}", deviceId, session.getUserId());

1
2
3
4
5
6

Map<String, String> vars = new HashMap<>();
vars.put("DeviceOS", System.getProperty("os.name"));
vars.put("GameVersion", "VersionNumber");
vars.put("InviterUserId", "<SomeUserId>");

Session session = client.authenticateDevice(deviceId, vars).get();

1

Map<String, String> vars = session.getVars()

1
2
3
4
5
6
7

logger.info("Session connected: {}", session.getAuthToken());

// Android
SharedPreferences pref = getActivity().getPreferences(Context.MODE_PRIVATE);
SharedPreferences.Editor editor = pref.edit();
editor.putString("nk.session", session.getAuthToken());
editor.commit();

1

session = DefaultSession.restore(authToken);

1
2
3
4
5

Account account = client.getAccount(session).get();
User user = account.getUser();
String username = user.getUsername();
String avatarUrl = user.getAvatarUrl();
String userId = user.getId();

1
2
3
4
5
6
7

String newUsername = "NotTheImp0ster";
String newDisplayName = "Innocent Dave";
String newAvatarUrl = "https://example.com/imposter.png";
String newLangTag = "en";
String newLocation = "Edinburgh";
String newTimezone = "BST";
client.updateAccount(session, newUsername, newDisplayName, newAvatarUrl, newLangTag, newLocation, newTimezone).get();

1
2
3
4
5
6
7
8
9

List<String> ids = Arrays.asList("userid1", "userid2");
List<String> usernames = Arrays.asList("username1", "username1");
String[] facebookIds = new String[] {"facebookid1"};

Users users = client.getUsers(session, ids, usernames, facebookIds).get();

for (User user : users.getUsersList()) {
  logger.info("User id {} username {}", user.getId(), user.getUsername());
}

1
2
3
4
5
6

public class Metadata
{
    public String Title;
    public String Hat;
    public String Skin;
}

1
2
3
4
5
6
7

// Get the updated account object.
Account account = client.getAccount(session).get();

// Parse the account user metadata and log the result.
Gson gson = new Gson();
Metadata metadata = gson.fromJson(account.getUser().getMetadata(), Metadata.class);
logger.info("Title: {}, Hat: {}, Skin: {}", metadata.Title, metadata.Hat, metadata.Skin);

1
2
3
4
5
6

Gson gson = new Gson();
Map<String, Double> wallet = new HashMap<>();
wallet = gson.fromJson(account.getWallet(), wallet.getClass());

logger.info("Wallet:");
wallet.forEach((k, v) -> logger.info("{}: {}", k, v));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

StorageObjectId objectId = new StorageObjectId("favorites");
objectId.setKey("Hats");
objectId.setUserId(session.getUserId());

StorageObjects objects = client.readStorageObjects(session, objectId).get();

objects.getObjectsList().forEach((object) -> {
    Map<String, Object> parsedObj = new Gson().fromJson(object.getValue(), new TypeToken<Map<String, Object>>(){}.getType());
    logger.info("{}:", object.getKey());
    parsedObj.forEach((k, v) -> logger.info("{}: {}", k, v));
});

1
2
3
4
5
6
7
8

// Serialize your object as JSON
Map<String, List<String>> favoriteHats = new HashMap<>();
favoriteHats.put("hats", Arrays.asList("cowboy", "alien"));
String favoriteHatsJson = new Gson().toJson(favoriteHats);

StorageObjectWrite writeObject = new StorageObjectWrite("favorites", "Hats", favoriteHatsJson, PermissionRead.OWNER_READ, PermissionWrite.OWNER_WRITE);
StorageObjectAcks acks = client.writeStorageObjects(session, writeObject).get();
logger.info("Stored objects {}", acks.getAcksList());

1
2
3
4
5
6
7
8

String favoriteHatsJson = "...";
String myStatsJson = "...";

StorageObjectWrite writeObject = new StorageObjectWrite("favorites", "Hats", favoriteHats, PermissionRead.OWNER_READ, PermissionWrite.OWNER_WRITE);
StorageObjectWrite statsObject = new StorageObjectWrite("stats", "player", myStats, PermissionRead.OWNER_READ, PermissionWrite.OWNER_WRITE);

StorageObjectAcks acks = client.writeStorageObjects(session, saveGameObject, statsObject).get();
System.out.format("Stored objects %s", acks.getAcksList());

1
2
3
4
5
6

// Assuming we already got an object (`obj`)
// Create a new object with the same Collection and Key and use the previous object's Version
StorageObjectWrite writeObject = new StorageObjectWrite(obj.getCollection(), obj.getKey(), newJsonValue, PermissionRead.OWNER_READ, PermissionWrite.OWNER_WRITE);
writeObject.setVersion(obj.getVersion())

// ... then write it to the Storage Engine as shown above

1
2
3
4
5
6

int limit = 3;
String cursor = null;

StorageObjectList objects = client.listUsersStorageObjects(session, "Unlocks", limit, cursor);
logger.info("Object count: {}", objects.getObjectsCount());
objects.getObjectsList().forEach(object -> logger.info("Key: {}", object.getKey()));

1

StorageObjectList objectsPage2 = lient.listUsersStorageObjects(session, "Unlocks", limit, objectsPage1.cursor);

1
2
3
4

String payload = "{ \"item\", \"cowboy\" }";

Rpc result = client.rpc(session, "EquipHat", payload).get();
logger.info("New hat equipped successfully {}", result.getPayload());

1
2

Rpc result = socket.rpc("EquipHat", payload).get();
logger.info("New hat equipped successfully {}", result.getPayload());

1
2
3
4
5
6
7

// Add friends by User ID.
List<String> ids = Arrays.asList("AlwaysTheImposter21", "SneakyBoi");

// Add friends by Username.
String[] usernames = new String[] { "<SomeUserId>", "<AnotherUserId>" };

client.addFriends(session, ids, usernames).get();

1
2
3
4
5
6

int friendshipState = 0;
int limit = 20; // Limit is capped at 1000
String cursor = null;

FriendList friends = client.listFriends(session, friendshipState, limit, cursor).get();
friends.getFriendsList().forEach(friend -> logger.info("Friend Id: {}", friend.getUser().getId()));

1
2
3
4
5
6
7

int friendshipState = 2;
FriendList friends = client.listFriends(session, friendshipState).get();

for (Friend friend : friends.getFriendsList()) {
    List<String> ids = Arrays.asList(friend.getUser().getId());
    client.addFriends(session, ids, null).get();
}

1
2
3
4
5
6
7

// Delete friends by User ID.
List<String> ids = Arrays.asList("<SomeUserId>", "<AnotherUserId>");

// Delete friends by Username.
String[] usernames = new String[] { "<SomeUsername>", "<AnotherUsername>" };

client.deleteFriends(session, ids, usernames).get();

1
2
3
4
5
6
7

// Block friends by User ID.
List<String> ids = Arrays.asList("<SomeUserId>", "<AnotherUserId>");

// Block friends by Username.
String[] usernames = new String[] { "<SomeUsername>", "<AnotherUsername>" };

client.blockFriends(session, ids, usernames).get();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// If one doesn't already exist, create a socket listener and handle status presence events
SocketListener socketListener = new SocketListener() {
    @Override
    public void onStatusPresence(StatusPresenceEvent e) {
        if (e.getJoins() != null) {
            e.getJoins().forEach(presence -> logger.info("{} is online with status {}", presence.getUsername(), presence.getStatus()));
        }

        if (e.getLeaves() != null) {
            e.getLeaves().forEach(presence -> logger.info("{} went offline", presence.getUsername()));
        }
    }

    // ... other required overrides (e.g. onChannelMessage etc)
}

// Then create and connect a socket connection
SocketClient socket = client.createSocket();
socket.connect(session, socketListener);

// Follow mutual friends and get the initial Status of any that are currently online
int friendshipState = 0; // Mutual friends
int limit = 20; // Limit is capped at 1000

FriendList friends = client.listFriends(session, friendshipState, limit, null).get();
List<String> friendIds = new ArrayList<>();
for (Friend friend : friends.getFriendsList()) {
    friendIds.add(friend.getUser().getId());
}

Status status = socket.followUsers(friendIds).get();
if (status.getPresences() != null) {
    status.getPresences().forEach(presence -> logger.info("{} is online with status {}", presence.getUsername(), presence.getStatus()));
}

1

socket.unfollowUsers("<UserId>", "<AnotherUserId>").get();

1

socket.updateStatus("Viewing the Main Menu").get();

1
2
3
4
5
6
7

String name = "Imposters R Us";
String description = "A group for people who love playing the imposter.";
String avatarUrl = "";
String langTag = "";
Boolean open = true; // Public group
int maxSize = 100;
Group group = client.createGroup(session, name, description, avatarUrl, langTag, open, maxSize).get();

1
2
3

String groupId = "<GroupId>";
boolean open = false;
client.updateGroup(session, groupId, name, description, avatarUrl, langTag, open);

1
2
3
4
5
6

int limit = 20;
GroupList groupList = client.listGroups(session, "imposter%", limit).get();
groupList.getGroupsList().forEach(group -> logger.info("{} [{}]", group.getName(), group.hasOpen() && group.getOpen().getValue() ? "Public" : "Private"));

// Get the next page of results.
GroupList nextGroupListResults = client.listGroups(session, "imposter%", limit, groupList.getCursor()).get();

1

client.deleteGroup(session, "<GroupId>").get();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

Map<String, Object> payload = new HashMap<>();
payload.put("GroupId", "<GroupId>");
payload.put("Interests", Arrays.asList("Deception", "Sabotage", "Cute Furry Bunnies"));
payload.put("ActiveTimes", Arrays.asList("9am-2pm Weekdays", "9am-10am Weekends"));
payload.put("Languages", Arrays.asList("English", "German"));

try {
    Rpc rpcResult = client.rpc(session, "UpdateGroupMetadata", new Gson().toJson(payload, payload.getClass())).get();
    logger.info("Successfully updated group metadata");
}
catch (ExecutionException ex) {
    logger.error(ex.getMessage());
}

1

client.joinGroup(session, "<GroupId>").get();

1
2
3
4
5
6

String userid = "<user id>";
UserGroupList userGroups = client.listUserGroups(session, userid).get();

for (UserGroupList.UserGroup userGroup : userGroups.getUserGroupsList()) {
    System.out.format("Group name %s role %d", userGroup.getGroup().getName(), userGroup.getState());
}

1
2

GroupUserList groupUserList = client.listGroupUsers(session, "<GroupId>").get();
groupUserList.getGroupUsersList().forEach(groupUser -> logger.info("{}: {}", groupUser.getUser().getId(), groupUser.getState().getValue()));

1
2
3
4
5
6
7

int state = 3;
int limit = 100;
String cursor = "";
GroupUserList groupUserList = client.listGroupUsers(session, groupId, state, limit, cursor).get();
groupUserList.getGroupUsersList().forEach(groupUser -> {
    client.addGroupUsers(session, groupId, groupUser.getUser().getId());
});

1

client.promoteGroupUsers(session, "<GroupId>", "UserId", "AnotherUserId").get();

1
2
3

String groupid = "<group id>";
String[] userIds = new String[] {"<user id>"};
client.demoteGroupUsers(session, groupid, userIds).get();

1

client.demoteGroupUsers(session, "<GroupId>", "UserId", "AnotherUserId").get();

1

client.banGroupUsers(session, "<GroupId>", "UserId", "AnotherUserId").get();

1

client.leaveGroup(session, "<GroupId>").get();

1
2
3
4
5

String roomName = "<MatchId>";
boolean persistence = false;
boolean hidden = false;
Channel channel = socket.joinChat(roomName, ChannelType.ROOM, persistence, hidden).get();
logger.info("Connected to dynamic room channel: {}", channel.getId());

1
2
3
4
5

String groupId = "<GroupId>";
boolean persistence = true;
boolean hidden = false;
Channel channel = socket.joinChat(groupId, ChannelType.GROUP, persistence, hidden).get();
logger.info("Connected to group channel: {}", channel.getId());

1
2
3
4
5

String userId = "<UserId>";
boolean persistence = true;
boolean hidden = false;
Channel channel = socket.joinChat(userId, ChannelType.DIRECT_MESSAGE, persistence, hidden).get();
logger.info("Connected to direct message channel: {}", channel.getId());

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

String channelId = "<ChannelId>";

Map<String, String> messageContent = new HashMap<>();
messageContent.put("message", "I think Red is the imposter!");
ChannelMessageAck messageSendAck = socket.writeChatMessage(channelId, new Gson().toJson(messageContent, messageContent.getClass())).get();

Map<String, String> emoteContent = new HashMap<>();
emoteContent.put("emote", "point");
emoteContent.put("emoteTarget", "<RedPlayerUserId>");
ChannelMessageAck emoteSendAck = socket.writeChatMessage(channelId, new Gson().toJson(emoteContent, emoteContent.getClass())).get();

1
2
3
4
5

int limit = 100;
boolean forward = true;
String groupId = "<GroupId>";
ChannelMessageList channelMessageList = client.listChannelMessages(session, channelId, limit, null, forward).get();
channelMessageList.getMessagesList().forEach(message -> logger.info("{}:{}", message.getUsername(), message.getContent()));

1
2
3
4
5

// Store this in whichever way suits your application
String cacheableCursor = channelMessageList.getCacheableCursor();

// ...then use the cacheable cursor later to retrieve the next results
ChannelMessageList nextResults = client.listChannelMessages(session, groupId, limit, cacheableCursor, forward);

1
2
3
4
5
6
7

Map<String, String> messageContent = new HashMap<>();
messageContent.put("message", "I think Red is the imposter!");
ChannelMessageAck ack = socket.writeChatMessage(channelId, new Gson().toJson(messageContent, messageContent.getClass())).get();

Map<String, String> updatedMessageContent = new HashMap<>();
updatedMessageContent.put("message", "I think BLUE is the imposter!");
ChannelMessageAck updateAck = socket.updateChatMessage(channelId, ack.getMessageId(), new Gson().toJson(updatedMessageContent, updatedMessageContent.getClass())).get();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

Match match = socket.createMatch().get();
FriendList friendList = client.listFriends(session, 0, 100, "").get();
for (Friend friend : friendList.getFriendsList()) {
    if (friend.getUser().getOnline()) {
        Map<String, String> messageContent = new HashMap<>();
        messageContent.put("message", String.format("Hey %s, join me for a match!", friend.getUser().getUsername()));
        messageContent.put("matchId", match.getMatchId());

        Channel channel = socket.joinChat(friend.getUser().getId(), ChannelType.DIRECT_MESSAGE).get();
        ChannelMessageAck ack = socket.writeChatMessage(channel.getId(), new Gson().toJson(messageContent, messageContent.getClass())).get();
    }
}

1
2

String matchId = "<MatchId>";
Match match = socket.joinMatch(matchId).get();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// In the SocketListener, override the onMatchmakerMatched function
@Override
public void onMatchmakerMatched(MatchmakerMatched matchmakerMatched) {
    Match match = socket.joinMatch(matchmakerMatched.getMatchId()).get();
}

// ...then, elsewhere
int minPlayers = 2;
int maxPlayers = 10;
String query = "";
MatchmakerTicket matchmakingTicket = socket.addMatchmaker(minPlayers, maxPlayers, query).get();

1
2
3
4
5

Map<String, String> status = new HashMap<>();
status.put("Status", "Playing a match");
status.put("MatchId", "<MatchId>");

socket.updateStatus(new Gson().toJson(status, status.getClass())).get();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@Override
public void onStatusPresence(StatusPresenceEvent e) {
    if (e.getJoins() != null) {
        e.getJoins().forEach(presence -> {
            Map<String, String> status = new Gson().fromJson(presence.getStatus(), new TypeToken<Map<String, String>>(){}.getType());
            if (status.containsKey("MatchId")) {
                socket.joinMatch(status.get("MatchId")).get();
            }
        });
    }
}

1
2
3
4
5
6
7

int minPlayers = 2;
int maxPlayers = 10;
int limit = 10;
boolean authoritative = true;
String label = "";
MatchList matchList = client.listMatches(session, minPlayers, maxPlayers, limit, label, authoritative).get();
matchList.getMatchesList().forEach(match -> logger.info("{}: {}/{}", match.getMatchId(), match.getSize(), limit));