Examples with RoomMember org.matrix.androidsdk.rest.model.RoomMember used on opensource projects

Example 16 with RoomMember

use of org.matrix.androidsdk.rest.model.RoomMember in project matrix-android-sdk by matrix-org.

the class MXDataHandler method retrieveLeftRooms.

/**
 * Retrieve the historical rooms
 *
 * @param callback the asynchronous callback.
 */
public void retrieveLeftRooms(ApiCallback<Void> callback) {
    // already loaded
    if (mAreLeftRoomsSynced) {
        if (null != callback) {
            callback.onSuccess(null);
        }
    } else {
        int count;
        synchronized (mLeftRoomsRefreshCallbacks) {
            if (null != callback) {
                mLeftRoomsRefreshCallbacks.add(callback);
            }
            count = mLeftRoomsRefreshCallbacks.size();
        }
        // start the request only for the first listener
        if (1 == count) {
            mIsRetrievingLeftRooms = true;
            Log.d(LOG_TAG, "## refreshHistoricalRoomsList() : requesting");
            mEventsRestClient.syncFromToken(null, 0, 30000, null, LEFT_ROOMS_FILTER, new ApiCallback<SyncResponse>() {

                @Override
                public void onSuccess(final SyncResponse syncResponse) {
                    Runnable r = new Runnable() {

                        @Override
                        public void run() {
                            if (null != syncResponse.rooms.leave) {
                                Set<String> roomIds = syncResponse.rooms.leave.keySet();
                                // Handle first joined rooms
                                for (String roomId : roomIds) {
                                    Room room = getRoom(mLeftRoomsStore, roomId, true);
                                    // sanity check
                                    if (null != room) {
                                        room.setIsLeft(true);
                                        room.handleJoinedRoomSync(syncResponse.rooms.leave.get(roomId), true);
                                        RoomMember selfMember = room.getState().getMember(getUserId());
                                        // keep only the left rooms (i.e not the banned / kicked ones)
                                        if ((null == selfMember) || !TextUtils.equals(selfMember.membership, RoomMember.MEMBERSHIP_LEAVE)) {
                                            mLeftRoomsStore.deleteRoom(roomId);
                                        }
                                    }
                                }
                                Log.d(LOG_TAG, "## refreshHistoricalRoomsList() : " + mLeftRoomsStore.getRooms().size() + " left rooms");
                            }
                            mIsRetrievingLeftRooms = false;
                            mAreLeftRoomsSynced = true;
                            synchronized (mLeftRoomsRefreshCallbacks) {
                                for (ApiCallback<Void> c : mLeftRoomsRefreshCallbacks) {
                                    c.onSuccess(null);
                                }
                                mLeftRoomsRefreshCallbacks.clear();
                            }
                        }
                    };
                    Thread t = new Thread(r);
                    t.setPriority(Thread.MIN_PRIORITY);
                    t.start();
                }

                @Override
                public void onNetworkError(Exception e) {
                    synchronized (mLeftRoomsRefreshCallbacks) {
                        Log.d(LOG_TAG, "## refreshHistoricalRoomsList() : failed " + e.getMessage());
                        for (ApiCallback<Void> c : mLeftRoomsRefreshCallbacks) {
                            c.onNetworkError(e);
                        }
                        mLeftRoomsRefreshCallbacks.clear();
                    }
                }

                @Override
                public void onMatrixError(MatrixError e) {
                    synchronized (mLeftRoomsRefreshCallbacks) {
                        Log.d(LOG_TAG, "## refreshHistoricalRoomsList() : failed " + e.getMessage());
                        for (ApiCallback<Void> c : mLeftRoomsRefreshCallbacks) {
                            c.onMatrixError(e);
                        }
                        mLeftRoomsRefreshCallbacks.clear();
                    }
                }

                @Override
                public void onUnexpectedError(Exception e) {
                    synchronized (mLeftRoomsRefreshCallbacks) {
                        Log.d(LOG_TAG, "## refreshHistoricalRoomsList() : failed " + e.getMessage());
                        for (ApiCallback<Void> c : mLeftRoomsRefreshCallbacks) {
                            c.onUnexpectedError(e);
                        }
                        mLeftRoomsRefreshCallbacks.clear();
                    }
                }
            });
        }
    }
}

Example 17 with RoomMember

use of org.matrix.androidsdk.rest.model.RoomMember in project matrix-android-sdk by matrix-org.

the class MXSession method toggleDirectChatRoom.

/**
 * Toggles the direct chat status of a room.<br>
 * Create a new direct chat room in the account data section if the room does not exist,
 * otherwise the room is removed from the account data section.
 * Direct chat room user ID choice algorithm:<br>
 * 1- oldest joined room member
 * 2- oldest invited room member
 * 3- the user himself
 *
 * @param roomId             the room roomId
 * @param aParticipantUserId the participant user id
 * @param callback           the asynchronous callback
 */
public void toggleDirectChatRoom(String roomId, String aParticipantUserId, ApiCallback<Void> callback) {
    IMXStore store = getDataHandler().getStore();
    Room room = store.getRoom(roomId);
    if (null != room) {
        HashMap<String, List<String>> params;
        if (null != store.getDirectChatRoomsDict()) {
            params = new HashMap<>(store.getDirectChatRoomsDict());
        } else {
            params = new HashMap<>();
        }
        // if the room was not yet seen as direct chat
        if (!getDataHandler().getDirectChatRoomIdsList().contains(roomId)) {
            List<String> roomIdsList = new ArrayList<>();
            RoomMember directChatMember = null;
            String chosenUserId;
            if (null == aParticipantUserId) {
                List<RoomMember> members = new ArrayList<>(room.getActiveMembers());
                // should never happen but it was reported by a GA issue
                if (members.isEmpty()) {
                    return;
                }
                if (members.size() > 1) {
                    // sort algo: oldest join first, then oldest invited
                    Collections.sort(members, new Comparator<RoomMember>() {

                        @Override
                        public int compare(RoomMember r1, RoomMember r2) {
                            int res;
                            long diff;
                            if (RoomMember.MEMBERSHIP_JOIN.equals(r2.membership) && RoomMember.MEMBERSHIP_INVITE.equals(r1.membership)) {
                                res = 1;
                            } else if (r2.membership.equals(r1.membership)) {
                                diff = r1.getOriginServerTs() - r2.getOriginServerTs();
                                res = (0 == diff) ? 0 : ((diff > 0) ? 1 : -1);
                            } else {
                                res = -1;
                            }
                            return res;
                        }
                    });
                    int nextIndexSearch = 0;
                    // take the oldest join member
                    if (!TextUtils.equals(members.get(0).getUserId(), getMyUserId())) {
                        if (RoomMember.MEMBERSHIP_JOIN.equals(members.get(0).membership)) {
                            directChatMember = members.get(0);
                        }
                    } else {
                        nextIndexSearch = 1;
                        if (RoomMember.MEMBERSHIP_JOIN.equals(members.get(1).membership)) {
                            directChatMember = members.get(1);
                        }
                    }
                    // no join member found, test the oldest join member
                    if (null == directChatMember) {
                        if (RoomMember.MEMBERSHIP_INVITE.equals(members.get(nextIndexSearch).membership)) {
                            directChatMember = members.get(nextIndexSearch);
                        }
                    }
                }
                // last option: get the logged user
                if (null == directChatMember) {
                    directChatMember = members.get(0);
                }
                chosenUserId = directChatMember.getUserId();
            } else {
                chosenUserId = aParticipantUserId;
            }
            // search if there is an entry with the same user
            if (params.containsKey(chosenUserId)) {
                roomIdsList = new ArrayList<>(params.get(chosenUserId));
            }
            // update room list with the new room
            roomIdsList.add(roomId);
            params.put(chosenUserId, roomIdsList);
        } else {
            // remove the current room from the direct chat list rooms
            if (null != store.getDirectChatRoomsDict()) {
                List<String> keysList = new ArrayList<>(params.keySet());
                for (String key : keysList) {
                    List<String> roomIdsList = params.get(key);
                    if (roomIdsList.contains(roomId)) {
                        roomIdsList.remove(roomId);
                        if (roomIdsList.isEmpty()) {
                            // Remove this entry
                            params.remove(key);
                        }
                    }
                }
            } else {
                // should not happen: if the room has to be removed, it means the room has been
                // previously detected as being part of the listOfList
                Log.e(LOG_TAG, "## toggleDirectChatRoom(): failed to remove a direct chat room (not seen as direct chat room)");
                return;
            }
        }
        // Store and upload the updated map
        getDataHandler().setDirectChatRoomsMap(params, callback);
    }
}

Example 18 with RoomMember

use of org.matrix.androidsdk.rest.model.RoomMember in project matrix-android-sdk by matrix-org.

the class CryptoTest method doE2ETestWithAliceAndBobInARoom.

private void doE2ETestWithAliceAndBobInARoom(boolean cryptedBob) throws Exception {
    final HashMap<String, String> statuses = new HashMap<>();
    doE2ETestWithAliceInARoom();
    Room room = mAliceSession.getDataHandler().getRoom(mRoomId);
    createBobAccount();
    final CountDownLatch lock0 = new CountDownLatch(1);
    mBobSession.enableCrypto(cryptedBob, new ApiCallback<Void>() {

        @Override
        public void onSuccess(Void info) {
            statuses.put("enableCrypto", "enableCrypto");
            lock0.countDown();
        }

        @Override
        public void onNetworkError(Exception e) {
            lock0.countDown();
        }

        @Override
        public void onMatrixError(MatrixError e) {
            lock0.countDown();
        }

        @Override
        public void onUnexpectedError(Exception e) {
            lock0.countDown();
        }
    });
    lock0.await(1000, TimeUnit.MILLISECONDS);
    final CountDownLatch lock1 = new CountDownLatch(2);
    MXEventListener bobEventListener = new MXEventListener() {

        @Override
        public void onNewRoom(String roomId) {
            if (TextUtils.equals(roomId, mRoomId)) {
                if (!statuses.containsKey("onNewRoom")) {
                    statuses.put("onNewRoom", "onNewRoom");
                    lock1.countDown();
                }
            }
        }
    };
    mBobSession.getDataHandler().addListener(bobEventListener);
    room.invite(mBobSession.getMyUserId(), new ApiCallback<Void>() {

        @Override
        public void onSuccess(Void info) {
            statuses.put("invite", "invite");
            lock1.countDown();
        }

        @Override
        public void onNetworkError(Exception e) {
            lock1.countDown();
        }

        @Override
        public void onMatrixError(MatrixError e) {
            lock1.countDown();
        }

        @Override
        public void onUnexpectedError(Exception e) {
            lock1.countDown();
        }
    });
    lock1.await(1000, TimeUnit.MILLISECONDS);
    assertTrue(statuses.containsKey("invite") && statuses.containsKey("onNewRoom"));
    mBobSession.getDataHandler().removeListener(bobEventListener);
    final CountDownLatch lock2 = new CountDownLatch(2);
    mBobSession.joinRoom(mRoomId, new ApiCallback<String>() {

        @Override
        public void onSuccess(String info) {
            statuses.put("joinRoom", "joinRoom");
            lock2.countDown();
        }

        @Override
        public void onNetworkError(Exception e) {
            statuses.put("onNetworkError", e.getMessage());
            lock2.countDown();
        }

        @Override
        public void onMatrixError(MatrixError e) {
            statuses.put("onMatrixError", e.getMessage());
            lock2.countDown();
        }

        @Override
        public void onUnexpectedError(Exception e) {
            statuses.put("onUnexpectedError", e.getMessage());
            lock2.countDown();
        }
    });
    room.addEventListener(new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_STATE_ROOM_MEMBER)) {
                JsonObject contentToConsider = event.getContentAsJsonObject();
                RoomMember member = JsonUtils.toRoomMember(contentToConsider);
                if (TextUtils.equals(member.membership, RoomMember.MEMBERSHIP_JOIN)) {
                    statuses.put("AliceJoin", "AliceJoin");
                    lock2.countDown();
                }
            }
        }
    });
    lock2.await(2000, TimeUnit.MILLISECONDS);
    assertTrue(statuses + "", statuses.containsKey("joinRoom"));
    assertTrue(statuses + "", statuses.containsKey("AliceJoin"));
    mBobSession.getDataHandler().removeListener(bobEventListener);
}

Example 19 with RoomMember

use of org.matrix.androidsdk.rest.model.RoomMember in project matrix-android-sdk by matrix-org.

the class MXCallsManager method createCallInRoom.

/**
 * Create an IMXCall in the room defines by its room Id.
 * -> for a 1:1 call, it is a standard call.
 * -> for a conference call,
 * ----> the conference user is invited to the room (if it was not yet invited)
 * ----> the call signaling room is created (or retrieved) with the conference
 * ----> and the call is started
 *
 * @param roomId   the room roomId
 * @param isVideo  true to start a video call
 * @param callback the async callback
 */
public void createCallInRoom(final String roomId, final boolean isVideo, final ApiCallback<IMXCall> callback) {
    Log.d(LOG_TAG, "createCallInRoom in " + roomId);
    final Room room = mSession.getDataHandler().getRoom(roomId);
    // sanity check
    if (null != room) {
        if (isSupported()) {
            int joinedMembers = room.getJoinedMembers().size();
            Log.d(LOG_TAG, "createCallInRoom : the room has " + joinedMembers + " joined members");
            if (joinedMembers > 1) {
                if (joinedMembers == 2) {
                    // So it seems safer to reject the call creation it it will fail.
                    if (room.isEncrypted() && mSession.getCrypto().warnOnUnknownDevices()) {
                        List<RoomMember> members = new ArrayList<>(room.getJoinedMembers());
                        String userId1 = members.get(0).getUserId();
                        String userId2 = members.get(1).getUserId();
                        // force the refresh to ensure that the devices list is up-to-date
                        mSession.getCrypto().checkUnknownDevices(Arrays.asList(userId1, userId2), new ApiCallback<Void>() {

                            @Override
                            public void onSuccess(Void anything) {
                                final IMXCall call = getCallWithCallId(null, true);
                                call.setRooms(room, room);
                                call.setIsVideo(isVideo);
                                dispatchOnOutgoingCall(call);
                                if (null != callback) {
                                    mUIThreadHandler.post(new Runnable() {

                                        @Override
                                        public void run() {
                                            callback.onSuccess(call);
                                        }
                                    });
                                }
                            }

                            @Override
                            public void onNetworkError(Exception e) {
                                if (null != callback) {
                                    callback.onNetworkError(e);
                                }
                            }

                            @Override
                            public void onMatrixError(MatrixError e) {
                                if (null != callback) {
                                    callback.onMatrixError(e);
                                }
                            }

                            @Override
                            public void onUnexpectedError(Exception e) {
                                if (null != callback) {
                                    callback.onUnexpectedError(e);
                                }
                            }
                        });
                    } else {
                        final IMXCall call = getCallWithCallId(null, true);
                        call.setIsVideo(isVideo);
                        dispatchOnOutgoingCall(call);
                        call.setRooms(room, room);
                        if (null != callback) {
                            mUIThreadHandler.post(new Runnable() {

                                @Override
                                public void run() {
                                    callback.onSuccess(call);
                                }
                            });
                        }
                    }
                } else {
                    Log.d(LOG_TAG, "createCallInRoom : inviteConferenceUser");
                    inviteConferenceUser(room, new ApiCallback<Void>() {

                        @Override
                        public void onSuccess(Void info) {
                            Log.d(LOG_TAG, "createCallInRoom : inviteConferenceUser succeeds");
                            getConferenceUserRoom(room.getRoomId(), new ApiCallback<Room>() {

                                @Override
                                public void onSuccess(Room conferenceRoom) {
                                    Log.d(LOG_TAG, "createCallInRoom : getConferenceUserRoom succeeds");
                                    final IMXCall call = getCallWithCallId(null, true);
                                    call.setRooms(room, conferenceRoom);
                                    call.setIsConference(true);
                                    call.setIsVideo(isVideo);
                                    dispatchOnOutgoingCall(call);
                                    if (null != callback) {
                                        mUIThreadHandler.post(new Runnable() {

                                            @Override
                                            public void run() {
                                                callback.onSuccess(call);
                                            }
                                        });
                                    }
                                }

                                @Override
                                public void onNetworkError(Exception e) {
                                    Log.d(LOG_TAG, "createCallInRoom : getConferenceUserRoom failed " + e.getMessage());
                                    if (null != callback) {
                                        callback.onNetworkError(e);
                                    }
                                }

                                @Override
                                public void onMatrixError(MatrixError e) {
                                    Log.d(LOG_TAG, "createCallInRoom : getConferenceUserRoom failed " + e.getMessage());
                                    if (null != callback) {
                                        callback.onMatrixError(e);
                                    }
                                }

                                @Override
                                public void onUnexpectedError(Exception e) {
                                    Log.d(LOG_TAG, "createCallInRoom : getConferenceUserRoom failed " + e.getMessage());
                                    if (null != callback) {
                                        callback.onUnexpectedError(e);
                                    }
                                }
                            });
                        }

                        @Override
                        public void onNetworkError(Exception e) {
                            Log.d(LOG_TAG, "createCallInRoom : inviteConferenceUser fails " + e.getMessage());
                            if (null != callback) {
                                callback.onNetworkError(e);
                            }
                        }

                        @Override
                        public void onMatrixError(MatrixError e) {
                            Log.d(LOG_TAG, "createCallInRoom : inviteConferenceUser fails " + e.getMessage());
                            if (null != callback) {
                                callback.onMatrixError(e);
                            }
                        }

                        @Override
                        public void onUnexpectedError(Exception e) {
                            Log.d(LOG_TAG, "createCallInRoom : inviteConferenceUser fails " + e.getMessage());
                            if (null != callback) {
                                callback.onUnexpectedError(e);
                            }
                        }
                    });
                }
            } else {
                if (null != callback) {
                    callback.onMatrixError(new MatrixError(MatrixError.NOT_SUPPORTED, "too few users"));
                }
            }
        } else {
            if (null != callback) {
                callback.onMatrixError(new MatrixError(MatrixError.NOT_SUPPORTED, "VOIP is not supported"));
            }
        }
    } else {
        if (null != callback) {
            callback.onMatrixError(new MatrixError(MatrixError.NOT_FOUND, "room not found"));
        }
    }
}

Example 20 with RoomMember

use of org.matrix.androidsdk.rest.model.RoomMember in project matrix-android-sdk by matrix-org.

the class MXCrypto method getE2eRooms.

/**
 * Provides the list of e2e rooms
 *
 * @return the list of e2e rooms
 */
private List<Room> getE2eRooms() {
    List<Room> e2eRooms = new ArrayList<>();
    // sanity checks
    if ((null == mSession.getDataHandler()) || (null == mSession.getDataHandler().getStore())) {
        return e2eRooms;
    }
    List<Room> rooms = new ArrayList<>(mSession.getDataHandler().getStore().getRooms());
    for (Room r : rooms) {
        if (r.isEncrypted()) {
            RoomMember me = r.getMember(mSession.getMyUserId());
            if (null != me) {
                String membership = me.membership;
                // ignore any rooms which we have left
                if (TextUtils.equals(membership, RoomMember.MEMBERSHIP_JOIN) || TextUtils.equals(membership, RoomMember.MEMBERSHIP_INVITE)) {
                    e2eRooms.add(r);
                }
            }
        }
    }
    return e2eRooms;
}