Examples with MatrixError org.matrix.androidsdk.core.model.MatrixError used on opensource projects

Example 26 with MatrixError

use of org.matrix.androidsdk.core.model.MatrixError in project matrix-android-sdk by matrix-org.

the class DataRetriever method backPaginate.

/**
 * Trigger a back pagination for a dedicated room from Token.
 *
 * @param store           the store to use
 * @param roomId          the room Id
 * @param token           the start token.
 * @param limit           the maximum number of messages to retrieve
 * @param roomEventFilter the filter to use
 * @param callback        the callback
 */
public void backPaginate(final IMXStore store, final String roomId, final String token, final int limit, final RoomEventFilter roomEventFilter, final ApiCallback<TokensChunkEvents> callback) {
    // reach the marker end
    if (TextUtils.equals(token, Event.PAGINATE_BACK_TOKEN_END)) {
        // nothing more to provide
        final android.os.Handler handler = new android.os.Handler(Looper.getMainLooper());
        // call the callback with a delay
        // to reproduce the same behaviour as a network request.
        // except for the initial request.
        Runnable r = new Runnable() {

            @Override
            public void run() {
                handler.postDelayed(new Runnable() {

                    public void run() {
                        callback.onSuccess(new TokensChunkEvents());
                    }
                }, 0);
            }
        };
        handler.post(r);
        return;
    }
    Log.d(LOG_TAG, "## backPaginate() : starts for roomId " + roomId);
    TokensChunkEvents storageResponse = store.getEarlierMessages(roomId, token, limit);
    putPendingToken(mPendingBackwardRequestTokenByRoomId, roomId, token);
    if (storageResponse != null) {
        final android.os.Handler handler = new android.os.Handler(Looper.getMainLooper());
        final TokensChunkEvents fStorageResponse = storageResponse;
        Log.d(LOG_TAG, "## backPaginate() : some data has been retrieved into the local storage (" + fStorageResponse.chunk.size() + " events)");
        // call the callback with a delay
        // to reproduce the same behaviour as a network request.
        // except for the initial request.
        Runnable r = new Runnable() {

            @Override
            public void run() {
                handler.postDelayed(new Runnable() {

                    public void run() {
                        String expectedToken = getPendingToken(mPendingBackwardRequestTokenByRoomId, roomId);
                        Log.d(LOG_TAG, "## backPaginate() : local store roomId " + roomId + " token " + token + " vs " + expectedToken);
                        if (TextUtils.equals(expectedToken, token)) {
                            clearPendingToken(mPendingBackwardRequestTokenByRoomId, roomId);
                            callback.onSuccess(fStorageResponse);
                        }
                    }
                }, 0);
            }
        };
        Thread t = new Thread(r);
        t.start();
    } else {
        Log.d(LOG_TAG, "## backPaginate() : trigger a remote request");
        mRestClient.getRoomMessagesFrom(roomId, token, EventTimeline.Direction.BACKWARDS, limit, roomEventFilter, new SimpleApiCallback<TokensChunkEvents>(callback) {

            @Override
            public void onSuccess(TokensChunkEvents tokensChunkEvents) {
                String expectedToken = getPendingToken(mPendingBackwardRequestTokenByRoomId, roomId);
                Log.d(LOG_TAG, "## backPaginate() succeeds : roomId " + roomId + " token " + token + " vs " + expectedToken);
                if (TextUtils.equals(expectedToken, token)) {
                    clearPendingToken(mPendingBackwardRequestTokenByRoomId, roomId);
                    // Watch for the one event overlap
                    Event oldestEvent = store.getOldestEvent(roomId);
                    if (tokensChunkEvents.chunk.size() != 0) {
                        tokensChunkEvents.chunk.get(0).mToken = tokensChunkEvents.start;
                        // there is no more data on server side
                        if (null == tokensChunkEvents.end) {
                            tokensChunkEvents.end = Event.PAGINATE_BACK_TOKEN_END;
                        }
                        tokensChunkEvents.chunk.get(tokensChunkEvents.chunk.size() - 1).mToken = tokensChunkEvents.end;
                        Event firstReturnedEvent = tokensChunkEvents.chunk.get(0);
                        if ((oldestEvent != null) && (firstReturnedEvent != null) && TextUtils.equals(oldestEvent.eventId, firstReturnedEvent.eventId)) {
                            tokensChunkEvents.chunk.remove(0);
                        }
                        store.storeRoomEvents(roomId, tokensChunkEvents, EventTimeline.Direction.BACKWARDS);
                    }
                    Log.d(LOG_TAG, "## backPaginate() succeed : roomId " + roomId + " token " + token + " got " + tokensChunkEvents.chunk.size());
                    callback.onSuccess(tokensChunkEvents);
                }
            }

            private void logErrorMessage(String expectedToken, String errorMessage) {
                Log.e(LOG_TAG, "## backPaginate() failed : roomId " + roomId + " token " + token + " expected " + expectedToken + " with " + errorMessage);
            }

            @Override
            public void onNetworkError(Exception e) {
                String expectedToken = getPendingToken(mPendingBackwardRequestTokenByRoomId, roomId);
                logErrorMessage(expectedToken, e.getMessage());
                // dispatch only if it is expected
                if (TextUtils.equals(token, expectedToken)) {
                    clearPendingToken(mPendingBackwardRequestTokenByRoomId, roomId);
                    callback.onNetworkError(e);
                }
            }

            @Override
            public void onMatrixError(MatrixError e) {
                String expectedToken = getPendingToken(mPendingBackwardRequestTokenByRoomId, roomId);
                logErrorMessage(expectedToken, e.getMessage());
                // dispatch only if it is expected
                if (TextUtils.equals(token, expectedToken)) {
                    clearPendingToken(mPendingBackwardRequestTokenByRoomId, roomId);
                    callback.onMatrixError(e);
                }
            }

            @Override
            public void onUnexpectedError(Exception e) {
                String expectedToken = getPendingToken(mPendingBackwardRequestTokenByRoomId, roomId);
                logErrorMessage(expectedToken, e.getMessage());
                // dispatch only if it is expected
                if (TextUtils.equals(token, expectedToken)) {
                    clearPendingToken(mPendingBackwardRequestTokenByRoomId, roomId);
                    callback.onUnexpectedError(e);
                }
            }
        });
    }
}

Example 27 with MatrixError

use of org.matrix.androidsdk.core.model.MatrixError in project matrix-android-sdk by matrix-org.

the class CryptoTest method test26_testBlackListUnverifiedDevices.

@Test
public // Check that the message can be decrypted by the Bob's device and the Sam's device
void test26_testBlackListUnverifiedDevices() throws Exception {
    Log.e(LOG_TAG, "test26_testBlackListUnverifiedDevices");
    Context context = InstrumentationRegistry.getContext();
    final Map<String, Object> results = new HashMap<>();
    CryptoTestData cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobAndSamInARoom();
    final MXSession aliceSession = cryptoTestData.getFirstSession();
    final String aliceRoomId = cryptoTestData.getRoomId();
    final MXSession bobSession = cryptoTestData.getSecondSession();
    final MXSession samSession = cryptoTestData.getThirdSession();
    final String messageFromAlice = "Hello I'm Alice!";
    Room roomFromBobPOV = bobSession.getDataHandler().getRoom(aliceRoomId);
    Room roomFromAlicePOV = aliceSession.getDataHandler().getRoom(aliceRoomId);
    Room roomFromSamPOV = samSession.getDataHandler().getRoom(aliceRoomId);
    Assert.assertTrue(roomFromBobPOV.isEncrypted());
    Assert.assertTrue(roomFromAlicePOV.isEncrypted());
    Assert.assertTrue(roomFromSamPOV.isEncrypted());
    CountDownLatch lock1 = new CountDownLatch(1);
    roomFromAlicePOV.sendEvent(mCryptoTestHelper.buildTextEvent(messageFromAlice, aliceSession, aliceRoomId), new TestApiCallback<Void>(lock1, false) {

        @Override
        public void onMatrixError(MatrixError e) {
            results.put("sendEventError", e);
            super.onMatrixError(e);
        }
    });
    mTestHelper.await(lock1);
    Assert.assertTrue(results.containsKey("sendEventError"));
    MXCryptoError error = (MXCryptoError) results.get("sendEventError");
    Assert.assertEquals(MXCryptoError.UNKNOWN_DEVICES_CODE, error.errcode);
    MXUsersDevicesMap<MXDeviceInfo> unknownDevices = (MXUsersDevicesMap<MXDeviceInfo>) error.mExceptionData;
    // only one bob device
    List<String> deviceInfos = unknownDevices.getUserDeviceIds(bobSession.getMyUserId());
    Assert.assertEquals(1, deviceInfos.size());
    Assert.assertTrue(deviceInfos.contains(bobSession.getCrypto().getMyDevice().deviceId));
    // only one Sam device
    deviceInfos = unknownDevices.getUserDeviceIds(samSession.getMyUserId());
    Assert.assertEquals(1, deviceInfos.size());
    Assert.assertTrue(deviceInfos.contains(samSession.getCrypto().getMyDevice().deviceId));
    CountDownLatch lock2 = new CountDownLatch(1);
    aliceSession.getCrypto().setDevicesKnown(Arrays.asList(bobSession.getCrypto().getMyDevice(), samSession.getCrypto().getMyDevice()), new TestApiCallback<Void>(lock2) {

        @Override
        public void onSuccess(Void info) {
            results.put("setDevicesKnown", "setDevicesKnown");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock2);
    Assert.assertTrue(results.containsKey("setDevicesKnown"));
    final CountDownLatch lock3 = new CountDownLatch(5);
    MXEventListener eventListenerBob1 = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE)) {
                mCryptoTestHelper.checkEncryptedEvent(event, aliceRoomId, messageFromAlice, aliceSession);
                results.put("onLiveEventBob1", "onLiveEvent");
                lock3.countDown();
            }
        }
    };
    MXEventListener eventListenerSam1 = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE)) {
                mCryptoTestHelper.checkEncryptedEvent(event, aliceRoomId, messageFromAlice, aliceSession);
                results.put("onLiveEventSam1", "onLiveEvent");
                lock3.countDown();
            }
        }
    };
    bobSession.getDataHandler().addListener(new MXEventListener() {

        @Override
        public void onToDeviceEvent(Event event) {
            results.put("onToDeviceEventBob", event);
            lock3.countDown();
        }
    });
    samSession.getDataHandler().addListener(new MXEventListener() {

        @Override
        public void onToDeviceEvent(Event event) {
            results.put("onToDeviceEventSam", event);
            lock3.countDown();
        }
    });
    roomFromBobPOV.addEventListener(eventListenerBob1);
    roomFromSamPOV.addEventListener(eventListenerSam1);
    roomFromAlicePOV.sendEvent(mCryptoTestHelper.buildTextEvent(messageFromAlice, aliceSession, aliceRoomId), new TestApiCallback<Void>(lock3) {

        @Override
        public void onSuccess(Void info) {
            lock3.countDown();
        }
    });
    mTestHelper.await(lock3);
    Assert.assertTrue(results.containsKey("onToDeviceEventBob"));
    Assert.assertTrue(results.containsKey("onToDeviceEventSam"));
    Assert.assertTrue(results.containsKey("onLiveEventBob1"));
    Assert.assertTrue(results.containsKey("onLiveEventSam1"));
    roomFromBobPOV.removeEventListener(eventListenerBob1);
    roomFromSamPOV.removeEventListener(eventListenerSam1);
    // play with the device black listing
    final List<CountDownLatch> activeLock = new ArrayList<>();
    final List<String> activeMessage = new ArrayList<>();
    MXEventListener eventListenerBob2 = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE)) {
                mCryptoTestHelper.checkEncryptedEvent(event, aliceRoomId, activeMessage.get(0), aliceSession);
                results.put("eventListenerBob2", "onLiveEvent");
                activeLock.get(0).countDown();
            } else if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE_ENCRYPTED)) {
                results.put("eventListenerEncyptedBob2", "onLiveEvent");
                activeLock.get(0).countDown();
            }
        }
    };
    MXEventListener eventListenerSam2 = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE)) {
                mCryptoTestHelper.checkEncryptedEvent(event, aliceRoomId, activeMessage.get(0), aliceSession);
                results.put("eventListenerSam2", "onLiveEvent");
                activeLock.get(0).countDown();
            } else if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE_ENCRYPTED)) {
                results.put("eventListenerEncyptedSam2", "onLiveEvent");
                activeLock.get(0).countDown();
            }
        }
    };
    roomFromBobPOV.addEventListener(eventListenerBob2);
    roomFromSamPOV.addEventListener(eventListenerSam2);
    Assert.assertFalse(aliceSession.getCrypto().getCryptoStore().getGlobalBlacklistUnverifiedDevices());
    CountDownLatch lock4 = new CountDownLatch(1);
    aliceSession.getCrypto().setGlobalBlacklistUnverifiedDevices(true, new TestApiCallback<Void>(lock4) {

        @Override
        public void onSuccess(Void info) {
            results.put("setGlobalBlacklistUnverifiedDevices True", "setGlobalBlacklistUnverifiedDevices");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock4);
    Assert.assertTrue(results.containsKey("setGlobalBlacklistUnverifiedDevices True"));
    Assert.assertTrue(aliceSession.getCrypto().getCryptoStore().getGlobalBlacklistUnverifiedDevices());
    // ensure that there is no received message
    results.clear();
    CountDownLatch lock5 = new CountDownLatch(3);
    activeLock.clear();
    activeLock.add(lock5);
    activeMessage.clear();
    activeMessage.add("message 1");
    roomFromAlicePOV.sendEvent(mCryptoTestHelper.buildTextEvent(activeMessage.get(0), aliceSession, aliceRoomId), new TestApiCallback<Void>(lock5));
    mTestHelper.await(lock5);
    Assert.assertFalse(results.containsKey("eventListenerBob2"));
    Assert.assertFalse(results.containsKey("eventListenerSam2"));
    Assert.assertTrue(results.containsKey("eventListenerEncyptedBob2"));
    Assert.assertTrue(results.containsKey("eventListenerEncyptedSam2"));
    CountDownLatch lock6 = new CountDownLatch(1);
    aliceSession.getCrypto().setGlobalBlacklistUnverifiedDevices(false, new TestApiCallback<Void>(lock6) {

        @Override
        public void onSuccess(Void info) {
            results.put("setGlobalBlacklistUnverifiedDevices false", "setGlobalBlacklistUnverifiedDevices");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock6);
    Assert.assertTrue(results.containsKey("setGlobalBlacklistUnverifiedDevices false"));
    Assert.assertFalse(aliceSession.getCrypto().getCryptoStore().getGlobalBlacklistUnverifiedDevices());
    // ensure that the messages are received
    results.clear();
    CountDownLatch lock7 = new CountDownLatch(3);
    activeLock.clear();
    activeLock.add(lock7);
    activeMessage.clear();
    activeMessage.add("message 2");
    roomFromAlicePOV.sendEvent(mCryptoTestHelper.buildTextEvent(activeMessage.get(0), aliceSession, aliceRoomId), new TestApiCallback<Void>(lock7));
    mTestHelper.await(lock7);
    Assert.assertTrue(results.containsKey("eventListenerBob2"));
    Assert.assertTrue(results.containsKey("eventListenerSam2"));
    Assert.assertFalse(results.containsKey("eventListenerEncyptedBob2"));
    Assert.assertFalse(results.containsKey("eventListenerEncyptedSam2"));
    // verify the bob device
    CountDownLatch lock8 = new CountDownLatch(1);
    aliceSession.getCrypto().setDeviceVerification(MXDeviceInfo.DEVICE_VERIFICATION_VERIFIED, bobSession.getCrypto().getMyDevice().deviceId, bobSession.getMyUserId(), new TestApiCallback<Void>(lock8) {

        @Override
        public void onSuccess(Void info) {
            results.put("setDeviceVerificationBob", "setDeviceVerificationBob");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock8);
    Assert.assertTrue(results.containsKey("setDeviceVerificationBob"));
    CountDownLatch lock9 = new CountDownLatch(1);
    aliceSession.getCrypto().setRoomBlacklistUnverifiedDevices(roomFromAlicePOV.getRoomId(), new TestApiCallback<Void>(lock9) {

        @Override
        public void onSuccess(Void info) {
            results.put("setRoomBlacklistUnverifiedDevices", "setRoomBlacklistUnverifiedDevices");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock9);
    Assert.assertTrue(results.containsKey("setRoomBlacklistUnverifiedDevices"));
    // ensure that the messages are received
    results.clear();
    CountDownLatch lock10 = new CountDownLatch(3);
    activeLock.clear();
    activeLock.add(lock10);
    activeMessage.clear();
    activeMessage.add("message 3");
    roomFromAlicePOV.sendEvent(mCryptoTestHelper.buildTextEvent(activeMessage.get(0), aliceSession, aliceRoomId), new TestApiCallback<Void>(lock10));
    mTestHelper.await(lock10);
    Assert.assertTrue(results.containsKey("eventListenerBob2"));
    Assert.assertFalse(results.containsKey("eventListenerSam2"));
    Assert.assertFalse(results.containsKey("eventListenerEncyptedBob2"));
    Assert.assertTrue(results.containsKey("eventListenerEncyptedSam2"));
    CountDownLatch lock11 = new CountDownLatch(1);
    aliceSession.getCrypto().setRoomUnBlacklistUnverifiedDevices(roomFromAlicePOV.getRoomId(), new TestApiCallback<Void>(lock11) {

        @Override
        public void onSuccess(Void info) {
            results.put("setRoomUnBlacklistUnverifiedDevices", "setRoomUnBlacklistUnverifiedDevices");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock11);
    Assert.assertTrue(results.containsKey("setRoomUnBlacklistUnverifiedDevices"));
    // ensure that the messages are received
    results.clear();
    CountDownLatch lock12 = new CountDownLatch(3);
    activeLock.clear();
    activeLock.add(lock12);
    activeMessage.clear();
    activeMessage.add("message 3");
    roomFromAlicePOV.sendEvent(mCryptoTestHelper.buildTextEvent(activeMessage.get(0), aliceSession, aliceRoomId), new TestApiCallback<Void>(lock12));
    mTestHelper.await(lock12);
    Assert.assertTrue(results.containsKey("eventListenerBob2"));
    Assert.assertTrue(results.containsKey("eventListenerSam2"));
    Assert.assertFalse(results.containsKey("eventListenerEncyptedBob2"));
    Assert.assertFalse(results.containsKey("eventListenerEncyptedSam2"));
    cryptoTestData.clear(context);
}

Example 28 with MatrixError

use of org.matrix.androidsdk.core.model.MatrixError in project matrix-android-sdk by matrix-org.

the class MXCryptoImpl method onCryptoEvent.

/**
 * Handle an m.room.encryption event.
 *
 * @param event the encryption event.
 */
private void onCryptoEvent(final CryptoEvent event) {
    final CryptoEventContent eventContent = event.getWireEventContent();
    final CryptoRoom room = mSession.getDataHandler().getRoom(event.getRoomId());
    // Check whether the event content must be encrypted for the invited members.
    boolean encryptForInvitedMembers = mCryptoConfig.mEnableEncryptionForInvitedMembers && room.shouldEncryptForInvitedMembers();
    ApiCallback<List<CryptoRoomMember>> callback = new ApiCallback<List<CryptoRoomMember>>() {

        @Override
        public void onSuccess(final List<CryptoRoomMember> info) {
            getEncryptingThreadHandler().post(new Runnable() {

                @Override
                public void run() {
                    setEncryptionInRoom(event.getRoomId(), eventContent.getAlgorithm(), true, info);
                }
            });
        }

        private void onError() {
            // Ensure setEncryption in room is done, even if there is a failure to fetch the room members
            getEncryptingThreadHandler().post(new Runnable() {

                @Override
                public void run() {
                    setEncryptionInRoom(event.getRoomId(), eventContent.getAlgorithm(), true, room.getState().getLoadedMembersCrypto());
                }
            });
        }

        @Override
        public void onNetworkError(Exception e) {
            Log.w(LOG_TAG, "[MXCrypto] onCryptoEvent: Warning: Unable to get all members from the HS. Fallback by using lazy-loaded members", e);
            onError();
        }

        @Override
        public void onMatrixError(MatrixError e) {
            Log.w(LOG_TAG, "[MXCrypto] onCryptoEvent: Warning: Unable to get all members from the HS. Fallback by using lazy-loaded members");
            onError();
        }

        @Override
        public void onUnexpectedError(Exception e) {
            Log.w(LOG_TAG, "[MXCrypto] onCryptoEvent: Warning: Unable to get all members from the HS. Fallback by using lazy-loaded members", e);
            onError();
        }
    };
    if (encryptForInvitedMembers) {
        room.getActiveMembersAsyncCrypto(callback);
    } else {
        room.getJoinedMembersAsyncCrypto(callback);
    }
}

Example 29 with MatrixError

use of org.matrix.androidsdk.core.model.MatrixError in project matrix-android-sdk by matrix-org.

the class MXCryptoImpl 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
 */
@Override
public void encryptEventContent(final JsonElement eventContent, final String eventType, final CryptoRoom 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(), e);
                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(), e);
                if (null != callback) {
                    callback.onUnexpectedError(e);
                }
            }
        });
        return;
    }
    final ApiCallback<List<CryptoRoomMember>> apiCallback = new SimpleApiCallback<List<CryptoRoomMember>>(callback) {

        @Override
        public void onSuccess(final List<CryptoRoomMember> members) {
            // just as you are sending a secret message?
            final List<String> userIds = new ArrayList<>();
            for (CryptoRoomMember m : members) {
                userIds.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.getState().encryptionAlgorithm();
                        if (null != algorithm) {
                            if (setEncryptionInRoom(room.getRoomId(), algorithm, false, members)) {
                                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, userIds, 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, CryptoEvent.EVENT_TYPE_MESSAGE_ENCRYPTED));
                                }
                            }

                            @Override
                            public void onNetworkError(final Exception e) {
                                Log.e(LOG_TAG, "## encryptEventContent() : onNetworkError " + e.getMessage(), e);
                                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(), e);
                                if (null != callback) {
                                    callback.onUnexpectedError(e);
                                }
                            }
                        });
                    } else {
                        final String algorithm = room.getState().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));
                                }
                            });
                        }
                    }
                }
            });
        }
    };
    // Check whether the event content must be encrypted for the invited members.
    boolean encryptForInvitedMembers = mCryptoConfig.mEnableEncryptionForInvitedMembers && room.shouldEncryptForInvitedMembers();
    if (encryptForInvitedMembers) {
        room.getActiveMembersAsyncCrypto(apiCallback);
    } else {
        room.getJoinedMembersAsyncCrypto(apiCallback);
    }
}

Example 30 with MatrixError

use of org.matrix.androidsdk.core.model.MatrixError 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, getLeftRoomsFilter(), 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.e(LOG_TAG, "## refreshHistoricalRoomsList() : failed " + e.getMessage(), e);
                        for (ApiCallback<Void> c : mLeftRoomsRefreshCallbacks) {
                            c.onNetworkError(e);
                        }
                        mLeftRoomsRefreshCallbacks.clear();
                    }
                }

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