Examples with ApiCallback org.matrix.androidsdk.rest.callback.ApiCallback used on opensource projects

Example 6 with ApiCallback

use of org.matrix.androidsdk.rest.callback.ApiCallback 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 7 with ApiCallback

use of org.matrix.androidsdk.rest.callback.ApiCallback in project matrix-android-sdk by matrix-org.

the class CryptoTest method test08_testAliceAndBobInACryptedRoom2.

@Test
public void test08_testAliceAndBobInACryptedRoom2() throws Exception {
    Log.e(LOG_TAG, "test08_testAliceAndBobInACryptedRoom2");
    doE2ETestWithAliceAndBobInARoom(true);
    mBobSession.getCrypto().setWarnOnUnknownDevices(false);
    mAliceSession.getCrypto().setWarnOnUnknownDevices(false);
    final Room roomFromBobPOV = mBobSession.getDataHandler().getRoom(mRoomId);
    final Room roomFromAlicePOV = mAliceSession.getDataHandler().getRoom(mRoomId);
    assertTrue(roomFromBobPOV.isEncrypted());
    assertTrue(roomFromAlicePOV.isEncrypted());
    mReceivedMessagesFromAlice = 0;
    mReceivedMessagesFromBob = 0;
    final ArrayList<CountDownLatch> list = new ArrayList<>();
    MXEventListener bobEventListener = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE) && !TextUtils.equals(event.getSender(), mBobSession.getMyUserId())) {
                try {
                    if (checkEncryptedEvent(event, mRoomId, messagesFromAlice.get(mReceivedMessagesFromAlice), mAliceSession)) {
                        mReceivedMessagesFromAlice++;
                        list.get(list.size() - 1).countDown();
                    }
                } catch (Exception e) {
                }
            }
        }
    };
    MXEventListener aliceEventListener = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE) && !TextUtils.equals(event.getSender(), mAliceSession.getMyUserId())) {
                try {
                    if (checkEncryptedEvent(event, mRoomId, messagesFromBob.get(mReceivedMessagesFromBob), mBobSession)) {
                        mReceivedMessagesFromBob++;
                    }
                    list.get(list.size() - 1).countDown();
                } catch (Exception e) {
                }
            }
        }
    };
    ApiCallback<Void> callback = new ApiCallback<Void>() {

        @Override
        public void onSuccess(Void info) {
        }

        @Override
        public void onNetworkError(Exception e) {
        }

        @Override
        public void onMatrixError(MatrixError e) {
        }

        @Override
        public void onUnexpectedError(Exception e) {
        }
    };
    roomFromBobPOV.addEventListener(bobEventListener);
    roomFromAlicePOV.addEventListener(aliceEventListener);
    list.add(new CountDownLatch(2));
    final HashMap<String, Object> results = new HashMap<>();
    mBobSession.getDataHandler().addListener(new MXEventListener() {

        @Override
        public void onToDeviceEvent(Event event) {
            results.put("onToDeviceEvent", event);
            list.get(0).countDown();
        }
    });
    roomFromAlicePOV.sendEvent(buildTextEvent(messagesFromAlice.get(mReceivedMessagesFromAlice), mAliceSession), callback);
    list.get(list.size() - 1).await(1000, TimeUnit.MILLISECONDS);
    assertTrue(results.containsKey("onToDeviceEvent"));
    assertTrue(1 == mReceivedMessagesFromAlice);
    list.add(new CountDownLatch(1));
    roomFromBobPOV.sendEvent(buildTextEvent(messagesFromBob.get(mReceivedMessagesFromBob), mBobSession), callback);
    list.get(list.size() - 1).await(1000, TimeUnit.MILLISECONDS);
    assertTrue(1 == mReceivedMessagesFromBob);
    list.add(new CountDownLatch(1));
    roomFromBobPOV.sendEvent(buildTextEvent(messagesFromBob.get(mReceivedMessagesFromBob), mBobSession), callback);
    list.get(list.size() - 1).await(1000, TimeUnit.MILLISECONDS);
    assertTrue(2 == mReceivedMessagesFromBob);
    list.add(new CountDownLatch(1));
    roomFromBobPOV.sendEvent(buildTextEvent(messagesFromBob.get(mReceivedMessagesFromBob), mBobSession), callback);
    list.get(list.size() - 1).await(1000, TimeUnit.MILLISECONDS);
    assertTrue(3 == mReceivedMessagesFromBob);
    list.add(new CountDownLatch(1));
    roomFromAlicePOV.sendEvent(buildTextEvent(messagesFromAlice.get(mReceivedMessagesFromAlice), mAliceSession), callback);
    list.get(list.size() - 1).await(1000, TimeUnit.MILLISECONDS);
    assertTrue(2 == mReceivedMessagesFromAlice);
}

Example 8 with ApiCallback

use of org.matrix.androidsdk.rest.callback.ApiCallback in project matrix-android-sdk by matrix-org.

the class MXCallsManager method checkPendingIncomingCalls.

/**
 * check if there is a pending incoming call
 */
public void checkPendingIncomingCalls() {
    // Log.d(LOG_TAG, "checkPendingIncomingCalls");
    mUIThreadHandler.post(new Runnable() {

        @Override
        public void run() {
            if (mxPendingIncomingCallId.size() > 0) {
                for (String callId : mxPendingIncomingCallId) {
                    final IMXCall call = getCallWithCallId(callId);
                    if (null != call) {
                        final Room room = call.getRoom();
                        // If there are some unknown devices, the answer event would not be encrypted.
                        if ((null != room) && room.isEncrypted() && mSession.getCrypto().warnOnUnknownDevices() && (room.getJoinedMembers().size() == 2)) {
                            // test if the encrypted events are sent only to the verified devices (any room)
                            mSession.getCrypto().getGlobalBlacklistUnverifiedDevices(new SimpleApiCallback<Boolean>() {

                                @Override
                                public void onSuccess(Boolean sendToVerifiedDevicesOnly) {
                                    if (sendToVerifiedDevicesOnly) {
                                        dispatchOnIncomingCall(call, null);
                                    } else {
                                        // test if the encrypted events are sent only to the verified devices (only this room)
                                        mSession.getCrypto().isRoomBlacklistUnverifiedDevices(room.getRoomId(), new SimpleApiCallback<Boolean>() {

                                            @Override
                                            public void onSuccess(Boolean sendToVerifiedDevicesOnly) {
                                                if (sendToVerifiedDevicesOnly) {
                                                    dispatchOnIncomingCall(call, null);
                                                } else {
                                                    List<RoomMember> members = new ArrayList<>(room.getJoinedMembers());
                                                    String userId1 = members.get(0).getUserId();
                                                    String userId2 = members.get(1).getUserId();
                                                    Log.d(LOG_TAG, "## checkPendingIncomingCalls() : check the unknown devices");
                                                    // 
                                                    mSession.getCrypto().checkUnknownDevices(Arrays.asList(userId1, userId2), new ApiCallback<Void>() {

                                                        @Override
                                                        public void onSuccess(Void anything) {
                                                            Log.d(LOG_TAG, "## checkPendingIncomingCalls() : no unknown device");
                                                            dispatchOnIncomingCall(call, null);
                                                        }

                                                        @Override
                                                        public void onNetworkError(Exception e) {
                                                            Log.e(LOG_TAG, "## checkPendingIncomingCalls() : checkUnknownDevices failed " + e.getMessage());
                                                            dispatchOnIncomingCall(call, null);
                                                        }

                                                        @Override
                                                        public void onMatrixError(MatrixError e) {
                                                            MXUsersDevicesMap<MXDeviceInfo> unknownDevices = null;
                                                            if (e instanceof MXCryptoError) {
                                                                MXCryptoError cryptoError = (MXCryptoError) e;
                                                                if (MXCryptoError.UNKNOWN_DEVICES_CODE.equals(cryptoError.errcode)) {
                                                                    unknownDevices = (MXUsersDevicesMap<MXDeviceInfo>) cryptoError.mExceptionData;
                                                                }
                                                            }
                                                            if (null != unknownDevices) {
                                                                Log.d(LOG_TAG, "## checkPendingIncomingCalls() : checkUnknownDevices found some unknown devices");
                                                            } else {
                                                                Log.e(LOG_TAG, "## checkPendingIncomingCalls() : checkUnknownDevices failed " + e.getMessage());
                                                            }
                                                            dispatchOnIncomingCall(call, unknownDevices);
                                                        }

                                                        @Override
                                                        public void onUnexpectedError(Exception e) {
                                                            Log.e(LOG_TAG, "## checkPendingIncomingCalls() : checkUnknownDevices failed " + e.getMessage());
                                                            dispatchOnIncomingCall(call, null);
                                                        }
                                                    });
                                                }
                                            }
                                        });
                                    }
                                }
                            });
                        } else {
                            dispatchOnIncomingCall(call, null);
                        }
                    }
                }
            }
            mxPendingIncomingCallId.clear();
        }
    });
}

Example 9 with ApiCallback

use of org.matrix.androidsdk.rest.callback.ApiCallback 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 10 with ApiCallback

use of org.matrix.androidsdk.rest.callback.ApiCallback in project matrix-android-sdk by matrix-org.

the class MXCrypto method encryptEventContent.

/**
 * Encrypt an event content according to the configuration of the room.
 *
 * @param eventContent the content of the event.
 * @param eventType    the type of the event.
 * @param room         the room the event will be sent.
 * @param callback     the asynchronous callback
 */
public void encryptEventContent(final JsonElement eventContent, final String eventType, final Room room, final ApiCallback<MXEncryptEventContentResult> callback) {
    // wait that the crypto is really started
    if (!isStarted()) {
        Log.d(LOG_TAG, "## encryptEventContent() : wait after e2e init");
        start(false, new ApiCallback<Void>() {

            @Override
            public void onSuccess(Void info) {
                encryptEventContent(eventContent, eventType, room, callback);
            }

            @Override
            public void onNetworkError(Exception e) {
                Log.e(LOG_TAG, "## encryptEventContent() : onNetworkError while waiting to start e2e : " + e.getMessage());
                if (null != callback) {
                    callback.onNetworkError(e);
                }
            }

            @Override
            public void onMatrixError(MatrixError e) {
                Log.e(LOG_TAG, "## encryptEventContent() : onMatrixError while waiting to start e2e : " + e.getMessage());
                if (null != callback) {
                    callback.onMatrixError(e);
                }
            }

            @Override
            public void onUnexpectedError(Exception e) {
                Log.e(LOG_TAG, "## encryptEventContent() : onUnexpectedError while waiting to start e2e : " + e.getMessage());
                if (null != callback) {
                    callback.onUnexpectedError(e);
                }
            }
        });
        return;
    }
    // just as you are sending a secret message?
    final ArrayList<String> userdIds = new ArrayList<>();
    Collection<RoomMember> joinedMembers = room.getJoinedMembers();
    for (RoomMember m : joinedMembers) {
        userdIds.add(m.getUserId());
    }
    getEncryptingThreadHandler().post(new Runnable() {

        @Override
        public void run() {
            IMXEncrypting alg;
            synchronized (mRoomEncryptors) {
                alg = mRoomEncryptors.get(room.getRoomId());
            }
            if (null == alg) {
                String algorithm = room.getLiveState().encryptionAlgorithm();
                if (null != algorithm) {
                    if (setEncryptionInRoom(room.getRoomId(), algorithm, false)) {
                        synchronized (mRoomEncryptors) {
                            alg = mRoomEncryptors.get(room.getRoomId());
                        }
                    }
                }
            }
            if (null != alg) {
                final long t0 = System.currentTimeMillis();
                Log.d(LOG_TAG, "## encryptEventContent() starts");
                alg.encryptEventContent(eventContent, eventType, userdIds, new ApiCallback<JsonElement>() {

                    @Override
                    public void onSuccess(final JsonElement encryptedContent) {
                        Log.d(LOG_TAG, "## encryptEventContent() : succeeds after " + (System.currentTimeMillis() - t0) + " ms");
                        if (null != callback) {
                            callback.onSuccess(new MXEncryptEventContentResult(encryptedContent, Event.EVENT_TYPE_MESSAGE_ENCRYPTED));
                        }
                    }

                    @Override
                    public void onNetworkError(final Exception e) {
                        Log.e(LOG_TAG, "## encryptEventContent() : onNetworkError " + e.getMessage());
                        if (null != callback) {
                            callback.onNetworkError(e);
                        }
                    }

                    @Override
                    public void onMatrixError(final MatrixError e) {
                        Log.e(LOG_TAG, "## encryptEventContent() : onMatrixError " + e.getMessage());
                        if (null != callback) {
                            callback.onMatrixError(e);
                        }
                    }

                    @Override
                    public void onUnexpectedError(final Exception e) {
                        Log.e(LOG_TAG, "## encryptEventContent() : onUnexpectedError " + e.getMessage());
                        if (null != callback) {
                            callback.onUnexpectedError(e);
                        }
                    }
                });
            } else {
                final String algorithm = room.getLiveState().encryptionAlgorithm();
                final String reason = String.format(MXCryptoError.UNABLE_TO_ENCRYPT_REASON, (null == algorithm) ? MXCryptoError.NO_MORE_ALGORITHM_REASON : algorithm);
                Log.e(LOG_TAG, "## encryptEventContent() : " + reason);
                if (null != callback) {
                    getUIHandler().post(new Runnable() {

                        @Override
                        public void run() {
                            callback.onMatrixError(new MXCryptoError(MXCryptoError.UNABLE_TO_ENCRYPT_ERROR_CODE, MXCryptoError.UNABLE_TO_ENCRYPT, reason));
                        }
                    });
                }
            }
        }
    });
}