Merge the matrix-java-sdk due to it no longer maintained. Remove thirdparty repositories.

src/main/java/io/kamax/matrix/client/regular/GlobalPushRulesSet.java

@@ -0,0 +1,68 @@
+/*
+ * matrix-java-sdk - Matrix Client SDK for Java
+ * Copyright (C) 2018 Kamax Sarl
+ *
+ * https://www.kamax.io/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package io.kamax.matrix.client.regular;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+import io.kamax.matrix.client._GlobalPushRulesSet;
+import io.kamax.matrix.json.GsonUtil;
+
+import java.util.List;
+
+public class GlobalPushRulesSet implements _GlobalPushRulesSet {
+
+    private JsonObject data;
+
+    public GlobalPushRulesSet(JsonObject data) {
+        this.data = data;
+    }
+
+    private List<JsonObject> getForKey(String key) {
+        return GsonUtil.asList(GsonUtil.findArray(data, key).orElseGet(JsonArray::new), JsonObject.class);
+    }
+
+    @Override
+    public List<JsonObject> getContent() {
+        return getForKey("content");
+    }
+
+    @Override
+    public List<JsonObject> getOverride() {
+        return getForKey("override");
+    }
+
+    @Override
+    public List<JsonObject> getRoom() {
+        return getForKey("room");
+    }
+
+    @Override
+    public List<JsonObject> getSender() {
+        return getForKey("sender");
+    }
+
+    @Override
+    public List<JsonObject> getUnderride() {
+        return getForKey("underride");
+    }
+
+}

src/main/java/io/kamax/matrix/client/regular/MatrixHttpClient.java

@@ -0,0 +1,292 @@
+/*
+ * matrix-java-sdk - Matrix Client SDK for Java
+ * Copyright (C) 2017 Kamax Sarl
+ *
+ * https://www.kamax.io/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package io.kamax.matrix.client.regular;
+
+import com.google.gson.JsonNull;
+import com.google.gson.JsonObject;
+
+import io.kamax.matrix.MatrixID;
+import io.kamax.matrix._MatrixContent;
+import io.kamax.matrix._MatrixID;
+import io.kamax.matrix._MatrixUser;
+import io.kamax.matrix.client.*;
+import io.kamax.matrix.hs._MatrixRoom;
+import io.kamax.matrix.json.*;
+import io.kamax.matrix.room.RoomAlias;
+import io.kamax.matrix.room.RoomAliasLookup;
+import io.kamax.matrix.room._RoomAliasLookup;
+import io.kamax.matrix.room._RoomCreationOptions;
+
+import org.apache.commons.codec.digest.HmacAlgorithms;
+import org.apache.commons.codec.digest.HmacUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.net.URI;
+import java.net.URL;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+
+import okhttp3.*;
+
+public class MatrixHttpClient extends AMatrixHttpClient implements _MatrixClient {
+
+    private Logger log = LoggerFactory.getLogger(MatrixHttpClient.class);
+
+    public MatrixHttpClient(String domain) {
+        super(domain);
+    }
+
+    public MatrixHttpClient(URL hsBaseUrl) {
+        super(hsBaseUrl);
+    }
+
+    public MatrixHttpClient(MatrixClientContext context) {
+        super(context);
+    }
+
+    public MatrixHttpClient(MatrixClientContext context, OkHttpClient.Builder client) {
+        super(context, client);
+    }
+
+    public MatrixHttpClient(MatrixClientContext context, OkHttpClient.Builder client, MatrixClientDefaults defaults) {
+        super(context, client, defaults);
+    }
+
+    public MatrixHttpClient(MatrixClientContext context, OkHttpClient client) {
+        super(context, client);
+    }
+
+    protected _MatrixID getIdentity(String token) {
+        URL path = getClientPath("account", "whoami");
+        String body = executeAuthenticated(new Request.Builder().get().url(path), token);
+        return MatrixID.from(GsonUtil.getStringOrThrow(GsonUtil.parseObj(body), "user_id")).acceptable();
+    }
+
+    @Override
+    public _MatrixID getWhoAmI() {
+        URL path = getClientPath("account", "whoami");
+        String body = executeAuthenticated(new Request.Builder().get().url(path));
+        return MatrixID.from(GsonUtil.getStringOrThrow(GsonUtil.parseObj(body), "user_id")).acceptable();
+    }
+
+    @Override
+    public void setDisplayName(String name) {
+        URL path = getClientPath("profile", getUserId(), "displayname");
+        execute(new Request.Builder().put(getJsonBody(new UserDisplaynameSetBody(name))).url(path));
+    }
+
+    @Override
+    public _RoomAliasLookup lookup(RoomAlias alias) {
+        URL path = getClientPath("directory", "room", alias.getId());
+        String resBody = execute(new Request.Builder().get().url(path));
+        RoomAliasLookupJson lookup = GsonUtil.get().fromJson(resBody, RoomAliasLookupJson.class);
+        return new RoomAliasLookup(lookup.getRoomId(), alias.getId(), lookup.getServers());
+    }
+
+    @Override
+    public _MatrixRoom createRoom(_RoomCreationOptions options) {
+        URL path = getClientPath("createRoom");
+        String resBody = executeAuthenticated(
+                new Request.Builder().post(getJsonBody(new RoomCreationRequestJson(options))).url(path));
+        String roomId = GsonUtil.get().fromJson(resBody, RoomCreationResponseJson.class).getRoomId();
+        return getRoom(roomId);
+    }
+
+    @Override
+    public _MatrixRoom getRoom(String roomId) {
+        return new MatrixHttpRoom(getContext(), roomId);
+    }
+
+    @Override
+    public List<_MatrixRoom> getJoinedRooms() {
+        URL path = getClientPath("joined_rooms");
+        JsonObject resBody = GsonUtil.parseObj(executeAuthenticated(new Request.Builder().get().url(path)));
+        return GsonUtil.asList(resBody, "joined_rooms", String.class).stream().map(this::getRoom)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public _MatrixRoom joinRoom(String roomIdOrAlias) {
+        URL path = getClientPath("join", roomIdOrAlias);
+        String resBody = executeAuthenticated(new Request.Builder().post(getJsonBody(new JsonObject())).url(path));
+        String roomId = GsonUtil.get().fromJson(resBody, RoomCreationResponseJson.class).getRoomId();
+        return getRoom(roomId);
+    }
+
+    @Override
+    public _MatrixUser getUser(_MatrixID mxId) {
+        return new MatrixHttpUser(getContext(), mxId);
+    }
+
+    @Override
+    public Optional<String> getDeviceId() {
+        return Optional.ofNullable(context.getDeviceId());
+    }
+
+    protected void updateContext(String resBody) {
+        LoginResponse response = gson.fromJson(resBody, LoginResponse.class);
+        context.setToken(response.getAccessToken());
+        context.setDeviceId(response.getDeviceId());
+        context.setUser(MatrixID.asAcceptable(response.getUserId()));
+    }
+
+    @Override
+    public void register(MatrixPasswordCredentials credentials, String sharedSecret, boolean admin) {
+        // As per synapse registration script:
+        // https://github.com/matrix-org/synapse/blob/master/scripts/register_new_matrix_user#L28
+
+        String value = credentials.getLocalPart() + "\0" + credentials.getPassword() + "\0"
+                + (admin ? "admin" : "notadmin");
+        String mac = new HmacUtils(HmacAlgorithms.HMAC_SHA_1, sharedSecret).hmacHex(value);
+        JsonObject body = new JsonObject();
+        body.addProperty("user", credentials.getLocalPart());
+        body.addProperty("password", credentials.getPassword());
+        body.addProperty("mac", mac);
+        body.addProperty("type", "org.matrix.login.shared_secret");
+        body.addProperty("admin", false);
+        URL url = getPath("client", "api", "v1", "register");
+        updateContext(execute(new Request.Builder().post(getJsonBody(body)).url(url)));
+    }
+
+    @Override
+    public void setAccessToken(String accessToken) {
+        context.setUser(getIdentity(accessToken));
+        context.setToken(accessToken);
+    }
+
+    @Override
+    public void login(MatrixPasswordCredentials credentials) {
+        URL url = getClientPath("login");
+
+        LoginPostBody data = new LoginPostBody(credentials.getLocalPart(), credentials.getPassword());
+        getDeviceId().ifPresent(data::setDeviceId);
+        Optional.ofNullable(context.getInitialDeviceName()).ifPresent(data::setInitialDeviceDisplayName);
+
+        updateContext(execute(new Request.Builder().post(getJsonBody(data)).url(url)));
+    }
+
+    @Override
+    public void logout() {
+        URL path = getClientPath("logout");
+        executeAuthenticated(new Request.Builder().post(getJsonBody(new JsonObject())).url(path));
+        context.setToken(null);
+        context.setUser(null);
+        context.setDeviceId(null);
+    }
+
+    @Override
+    public _SyncData sync(_SyncOptions options) {
+        long start = System.currentTimeMillis();
+        HttpUrl.Builder path = getClientPathBuilder("sync");
+        path.addQueryParameter("timeout", options.getTimeout().map(Long::intValue).orElse(30000).toString());
+        options.getSince().ifPresent(since -> path.addQueryParameter("since", since));
+        options.getFilter().ifPresent(filter -> path.addQueryParameter("filter", filter));
+        options.withFullState().ifPresent(state -> path.addQueryParameter("full_state", state ? "true" : "false"));
+        options.getSetPresence().ifPresent(presence -> path.addQueryParameter("presence", presence));
+
+        String body = executeAuthenticated(new Request.Builder().get().url(path.build().url()));
+        long request = System.currentTimeMillis();
+        log.info("Sync: network request took {} ms", (request - start));
+        SyncDataJson data = new SyncDataJson(GsonUtil.parseObj(body));
+        long parsing = System.currentTimeMillis();
+        log.info("Sync: parsing took {} ms", (parsing - request));
+        return data;
+    }
+
+    @Override
+    public _MatrixContent getMedia(String mxUri) throws IllegalArgumentException {
+        return getMedia(URI.create(mxUri));
+    }
+
+    @Override
+    public _MatrixContent getMedia(URI mxUri) throws IllegalArgumentException {
+        return new MatrixHttpContent(context, mxUri);
+    }
+
+    private String putMedia(Request.Builder builder, String filename) {
+        HttpUrl.Builder b = getMediaPathBuilder("upload");
+        if (StringUtils.isNotEmpty(filename)) b.addQueryParameter("filename", filename);
+
+        String body = executeAuthenticated(builder.url(b.build()));
+        return GsonUtil.getStringOrThrow(GsonUtil.parseObj(body), "content_uri");
+    }
+
+    @Override
+    public String putMedia(byte[] data, String type) {
+        return putMedia(data, type, null);
+    }
+
+    @Override
+    public String putMedia(byte[] data, String type, String filename) {
+        return putMedia(new Request.Builder().post(RequestBody.create(MediaType.parse(type), data)), filename);
+    }
+
+    @Override
+    public String putMedia(File data, String type) {
+        return putMedia(data, type, null);
+    }
+
+    @Override
+    public String putMedia(File data, String type, String filename) {
+        return putMedia(new Request.Builder().post(RequestBody.create(MediaType.parse(type), data)), filename);
+    }
+
+    @Override
+    public List<JsonObject> getPushers() {
+        URL url = getClientPath("pushers");
+        JsonObject response = GsonUtil.parseObj(executeAuthenticated(new Request.Builder().get().url(url)));
+        return GsonUtil.findArray(response, "pushers").map(array -> GsonUtil.asList(array, JsonObject.class))
+                .orElse(Collections.emptyList());
+    }
+
+    @Override
+    public void setPusher(JsonObject pusher) {
+        URL url = getClientPath("pushers", "set");
+        executeAuthenticated(new Request.Builder().url(url).post(getJsonBody(pusher)));
+    }
+
+    @Override
+    public void deletePusher(String pushKey) {
+        JsonObject pusher = new JsonObject();
+        pusher.add("kind", JsonNull.INSTANCE);
+        pusher.addProperty("pushkey", pushKey);
+        setPusher(pusher);
+    }
+
+    @Override
+    public _GlobalPushRulesSet getPushRules() {
+        URL url = getClientPath("pushrules", "global", "");
+        JsonObject response = GsonUtil.parseObj(executeAuthenticated(new Request.Builder().url(url).get()));
+        return new GlobalPushRulesSet(response);
+    }
+
+    @Override
+    public _PushRule getPushRule(String scope, String kind, String id) {
+        return new MatrixHttpPushRule(context, scope, kind, id);
+    }
+
+}

src/main/java/io/kamax/matrix/client/regular/Presence.java

@@ -0,0 +1,48 @@
+/*
+ * matrix-java-sdk - Matrix Client SDK for Java
+ * Copyright (C) 2018 Kamax Sàrl
+ *
+ * https://www.kamax.io/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package io.kamax.matrix.client.regular;
+
+import com.google.gson.JsonObject;
+
+import io.kamax.matrix.client._Presence;
+import io.kamax.matrix.json.GsonUtil;
+
+public class Presence implements _Presence {
+
+    private String status;
+    private Long lastActive;
+
+    public Presence(JsonObject json) {
+        this.status = GsonUtil.getStringOrThrow(json, "presence");
+        this.lastActive = GsonUtil.getLong(json, "last_active_ago");
+    }
+
+    @Override
+    public String getStatus() {
+        return status;
+    }
+
+    @Override
+    public Long getLastActive() {
+        return lastActive;
+    }
+
+}

src/main/java/io/kamax/matrix/client/regular/SyncDataJson.java

@@ -0,0 +1,390 @@
+/*
+ * matrix-java-sdk - Matrix Client SDK for Java
+ * Copyright (C) 2018 Kamax Sarl
+ *
+ * https://www.kamax.io/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package io.kamax.matrix.client.regular;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+
+import io.kamax.matrix.MatrixID;
+import io.kamax.matrix._MatrixID;
+import io.kamax.matrix.client._SyncData;
+import io.kamax.matrix.event.EventKey;
+import io.kamax.matrix.event._MatrixAccountDataEvent;
+import io.kamax.matrix.event._MatrixEphemeralEvent;
+import io.kamax.matrix.event._MatrixPersistentEvent;
+import io.kamax.matrix.event._MatrixStateEvent;
+import io.kamax.matrix.json.MatrixJsonObject;
+
+import java.util.*;
+
+public class SyncDataJson extends MatrixJsonObject implements _SyncData {
+
+    public class MatrixPersistentEventJson extends MatrixJsonObject implements _MatrixPersistentEvent {
+
+        public MatrixPersistentEventJson(JsonObject obj) {
+            super(obj);
+        }
+
+        @Override
+        public String getId() {
+            return findString(EventKey.Id.get()).orElse(""); // FIXME refactor event structure
+        }
+
+        @Override
+        public String getType() {
+            return getString(EventKey.Type.get());
+        }
+
+        @Override
+        public Long getTime() {
+            return getLong(EventKey.Timestamp.get());
+        }
+
+        @Override
+        public _MatrixID getSender() {
+            return MatrixID.from(getString(EventKey.Sender.get())).acceptable();
+        }
+    }
+
+    public class MatrixEphemeralEventJson extends MatrixJsonObject implements _MatrixEphemeralEvent {
+
+        public MatrixEphemeralEventJson(JsonObject obj) {
+            super(obj);
+        }
+
+        @Override
+        public String getType() {
+            return getString(EventKey.Type.get());
+        }
+
+    }
+
+    public class MatrixAccountDataEventJson extends MatrixJsonObject implements _MatrixAccountDataEvent {
+
+        public MatrixAccountDataEventJson(JsonObject obj) {
+            super(obj);
+        }
+
+        @Override
+        public String getType() {
+            return getString(EventKey.Type.get());
+        }
+
+    }
+
+    public class MatrixStateEventJson extends MatrixPersistentEventJson implements _MatrixStateEvent {
+
+        public MatrixStateEventJson(JsonObject obj) {
+            super(obj);
+        }
+
+        @Override
+        public String getStateKey() {
+            return getString(EventKey.StateKey.get());
+        }
+
+    }
+
+    public class StateJson extends MatrixJsonObject implements _SyncData.State {
+
+        private List<_MatrixStateEvent> events = new ArrayList<>();
+
+        public StateJson(JsonObject obj) {
+            super(obj);
+
+            findArray("events").ifPresent(array -> {
+                for (JsonElement el : array) {
+                    events.add(new MatrixStateEventJson(asObj(el)));
+                }
+            });
+        }
+
+        @Override
+        public List<_MatrixStateEvent> getEvents() {
+            return events;
+        }
+    }
+
+    public class TimelineJson extends MatrixJsonObject implements _SyncData.Timeline {
+
+        private List<_MatrixPersistentEvent> events = new ArrayList<>();
+
+        public TimelineJson(JsonObject obj) {
+            super(obj);
+
+            findArray("events").ifPresent(array -> {
+                for (JsonElement el : array) {
+                    events.add(new MatrixPersistentEventJson(asObj(el)));
+                }
+            });
+        }
+
+        @Override
+        public List<_MatrixPersistentEvent> getEvents() {
+            return events;
+        }
+
+        @Override
+        public boolean isLimited() {
+            return findString("limited").map("true"::equals).orElse(false);
+        }
+
+        @Override
+        public String getPreviousBatchToken() {
+            return getString("prev_batch");
+        }
+    }
+
+    public class EphemeralJson extends MatrixJsonObject implements _SyncData.Ephemeral {
+
+        private List<_MatrixEphemeralEvent> events = new ArrayList<>();
+
+        public EphemeralJson(JsonObject obj) {
+            super(obj);
+
+            findArray("events").ifPresent(array -> {
+                for (JsonElement el : array) {
+                    events.add(new MatrixEphemeralEventJson(asObj(el)));
+                }
+            });
+        }
+
+        @Override
+        public List<_MatrixEphemeralEvent> getEvents() {
+            return events;
+        }
+    }
+
+    public class AccountDataJson extends MatrixJsonObject implements _SyncData.AccountData {
+
+        private List<_MatrixAccountDataEvent> events = new ArrayList<>();
+
+        public AccountDataJson(JsonObject obj) {
+            super(obj);
+
+            findArray("events").ifPresent(array -> {
+                for (JsonElement el : array) {
+                    events.add(new MatrixAccountDataEventJson(asObj(el)));
+                }
+            });
+        }
+
+        @Override
+        public List<_MatrixAccountDataEvent> getEvents() {
+            return events;
+        }
+    }
+
+    public class InvitedRoomJson extends MatrixJsonObject implements _SyncData.InvitedRoom {
+
+        private String id;
+        private State state;
+
+        public InvitedRoomJson(String id, JsonObject data) {
+            super(data);
+            this.id = id;
+            this.state = new StateJson(findObj("invite_state").orElseGet(JsonObject::new));
+        }
+
+        @Override
+        public String getId() {
+            return id;
+        }
+
+        @Override
+        public State getState() {
+            return state;
+        }
+    }
+
+    public class UnreadNotificationsJson extends MatrixJsonObject implements _SyncData.UnreadNotifications {
+
+        private long highlights;
+        private long global;
+
+        public UnreadNotificationsJson(JsonObject data) {
+            super(data);
+            this.highlights = findLong("highlight_count").orElse(0L);
+            this.global = findLong("notification_count").orElse(0L);
+        }
+
+        @Override
+        public long getHighlightCount() {
+            return highlights;
+        }
+
+        @Override
+        public long getNotificationCount() {
+            return global;
+        }
+
+    }
+
+    public class JoinedRoomJson extends MatrixJsonObject implements _SyncData.JoinedRoom {
+
+        private String id;
+        private State state;
+        private Timeline timeline;
+        private UnreadNotifications unreadNotifications;
+        private Ephemeral ephemeral;
+        private AccountData accountData;
+
+        public JoinedRoomJson(String id, JsonObject data) {
+            super(data);
+            this.id = id;
+            this.state = new StateJson(findObj("state").orElseGet(JsonObject::new));
+            this.timeline = new TimelineJson(findObj("timeline").orElseGet(JsonObject::new));
+            this.unreadNotifications = new UnreadNotificationsJson(computeObj("unread_notifications"));
+            this.ephemeral = new EphemeralJson(findObj("ephemeral").orElseGet(JsonObject::new));
+            this.accountData = new AccountDataJson(findObj("account_data").orElseGet(JsonObject::new));
+        }
+
+        @Override
+        public String getId() {
+            return id;
+        }
+
+        @Override
+        public State getState() {
+            return state;
+        }
+
+        @Override
+        public Timeline getTimeline() {
+            return timeline;
+        }
+
+        @Override
+        public Ephemeral getEphemeral() {
+            return ephemeral;
+        }
+
+        @Override
+        public AccountData getAccountData() {
+            return accountData;
+        }
+
+        @Override
+        public UnreadNotifications getUnreadNotifications() {
+            return unreadNotifications;
+        }
+    }
+
+    public class LeftRoomJson extends MatrixPersistentEventJson implements _SyncData.LeftRoom {
+
+        private String id;
+        private State state;
+        private Timeline timeline;
+
+        public LeftRoomJson(String id, JsonObject data) {
+            super(data);
+            this.id = id;
+            this.state = new StateJson(findObj("state").orElseGet(JsonObject::new));
+            this.timeline = new TimelineJson(findObj("timeline").orElseGet(JsonObject::new));
+        }
+
+        @Override
+        public String getId() {
+            return id;
+        }
+
+        @Override
+        public State getState() {
+            return state;
+        }
+
+        @Override
+        public Timeline getTimeline() {
+            return timeline;
+        }
+    }
+
+    public class RoomsJson extends MatrixJsonObject implements _SyncData.Rooms {
+
+        private Set<InvitedRoom> invited = new HashSet<>();
+        private Set<JoinedRoom> joined = new HashSet<>();
+        private Set<LeftRoom> left = new HashSet<>();
+
+        public RoomsJson(JsonObject obj) {
+            super(obj);
+            findObj("invite").ifPresent(o -> {
+                for (Map.Entry<String, JsonElement> entry : o.entrySet()) {
+                    invited.add(new InvitedRoomJson(entry.getKey(), asObj(entry.getValue())));
+                }
+            });
+
+            findObj("join").ifPresent(o -> {
+                for (Map.Entry<String, JsonElement> entry : o.entrySet()) {
+                    joined.add(new JoinedRoomJson(entry.getKey(), asObj(entry.getValue())));
+                }
+            });
+
+            findObj("leave").ifPresent(o -> {
+                for (Map.Entry<String, JsonElement> entry : o.entrySet()) {
+                    left.add(new LeftRoomJson(entry.getKey(), asObj(entry.getValue())));
+                }
+            });
+        }
+
+        @Override
+        public Set<InvitedRoom> getInvited() {
+            return invited;
+        }
+
+        @Override
+        public Set<JoinedRoom> getJoined() {
+            return joined;
+        }
+
+        @Override
+        public Set<LeftRoom> getLeft() {
+            return left;
+        }
+
+    }
+
+    private String nextBatch;
+    private AccountDataJson accountData;
+    private RoomsJson rooms;
+
+    public SyncDataJson(JsonObject data) {
+        super(data);
+        nextBatch = getString("next_batch");
+        accountData = new AccountDataJson(findObj("account_data").orElseGet(JsonObject::new));
+        rooms = new RoomsJson(findObj("rooms").orElseGet(JsonObject::new));
+    }
+
+    @Override
+    public String nextBatchToken() {
+        return nextBatch;
+    }
+
+    @Override
+    public AccountData getAccountData() {
+        return accountData;
+    }
+
+    @Override
+    public Rooms getRooms() {
+        return rooms;
+    }
+
+}

src/main/java/io/kamax/matrix/client/regular/SyncOptions.java

@@ -0,0 +1,103 @@
+/*
+ * matrix-java-sdk - Matrix Client SDK for Java
+ * Copyright (C) 2018 Kamax Sarl
+ *
+ * https://www.kamax.io/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package io.kamax.matrix.client.regular;
+
+import io.kamax.matrix.client._SyncOptions;
+
+import java.util.Optional;
+
+public class SyncOptions implements _SyncOptions {
+
+    public static class Builder {
+
+        private final SyncOptions obj;
+
+        public Builder() {
+            this.obj = new SyncOptions();
+        }
+
+        public SyncOptions get() {
+            return obj;
+        }
+
+        public Builder setSince(String since) {
+            obj.since = since;
+            return this;
+        }
+
+        public Builder setFilter(String filter) {
+            obj.filter = filter;
+            return this;
+        }
+
+        public Builder setWithFullState(boolean withFullState) {
+            obj.fullState = withFullState;
+            return this;
+        }
+
+        public Builder setPresence(boolean setPresence) {
+            obj.setPresence = setPresence ? null : "offline";
+            return this;
+        }
+
+        public Builder setTimeout(long timeout) {
+            obj.timeout = timeout;
+            return this;
+        }
+
+    }
+
+    public static Builder build() {
+        return new Builder();
+    }
+
+    private String since;
+    private String filter;
+    private Boolean fullState;
+    private String setPresence;
+    private Long timeout;
+
+    @Override
+    public Optional<String> getSince() {
+        return Optional.ofNullable(since);
+    }
+
+    @Override
+    public Optional<String> getFilter() {
+        return Optional.ofNullable(filter);
+    }
+
+    @Override
+    public Optional<Boolean> withFullState() {
+        return Optional.ofNullable(fullState);
+    }
+
+    @Override
+    public Optional<String> getSetPresence() {
+        return Optional.ofNullable(setPresence);
+    }
+
+    @Override
+    public Optional<Long> getTimeout() {
+        return Optional.ofNullable(timeout);
+    }
+
+}