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

Example 6 with ApiCallback

use of org.matrix.androidsdk.core.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(() -> {
        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() != null && mSession.getCrypto().warnOnUnknownDevices() && room.getNumberOfJoinedMembers() == 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 {
                                                room.getJoinedMembersAsync(new ApiCallback<List<RoomMember>>() {

                                                    @Override
                                                    public void onNetworkError(Exception e) {
                                                        dispatchOnIncomingCall(call, null);
                                                    }

                                                    @Override
                                                    public void onMatrixError(MatrixError e) {
                                                        dispatchOnIncomingCall(call, null);
                                                    }

                                                    @Override
                                                    public void onUnexpectedError(Exception e) {
                                                        dispatchOnIncomingCall(call, null);
                                                    }

                                                    @Override
                                                    public void onSuccess(List<RoomMember> members) {
                                                        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(), e);
                                                                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(), e);
                                                                dispatchOnIncomingCall(call, null);
                                                            }
                                                        });
                                                    }
                                                });
                                            }
                                        }
                                    });
                                }
                            }
                        });
                    } else {
                        dispatchOnIncomingCall(call, null);
                    }
                }
            }
        }
        mxPendingIncomingCallId.clear();
    });
}

Example 7 with ApiCallback

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

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

use of org.matrix.androidsdk.core.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, 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();
                    }
                }
            });
        }
    }
}

Example 10 with ApiCallback

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

the class MXMegolmDecryption method shareKeysWithDevice.

@Override
public void shareKeysWithDevice(final IncomingRoomKeyRequest request) {
    // sanity checks
    if ((null == request) || (null == request.mRequestBody)) {
        return;
    }
    final String userId = request.mUserId;
    mCrypto.getDeviceList().downloadKeys(Arrays.asList(userId), false, new ApiCallback<MXUsersDevicesMap<MXDeviceInfo>>() {

        @Override
        public void onSuccess(MXUsersDevicesMap<MXDeviceInfo> devicesMap) {
            final String deviceId = request.mDeviceId;
            final MXDeviceInfo deviceInfo = mCrypto.mCryptoStore.getUserDevice(deviceId, userId);
            if (null != deviceInfo) {
                final RoomKeyRequestBody body = request.mRequestBody;
                Map<String, List<MXDeviceInfo>> devicesByUser = new HashMap<>();
                devicesByUser.put(userId, new ArrayList<>(Arrays.asList(deviceInfo)));
                mCrypto.ensureOlmSessionsForDevices(devicesByUser, new ApiCallback<MXUsersDevicesMap<MXOlmSessionResult>>() {

                    @Override
                    public void onSuccess(MXUsersDevicesMap<MXOlmSessionResult> map) {
                        MXOlmSessionResult olmSessionResult = map.getObject(deviceId, userId);
                        if ((null == olmSessionResult) || (null == olmSessionResult.mSessionId)) {
                            // so just skip it.
                            return;
                        }
                        Log.d(LOG_TAG, "## shareKeysWithDevice() : sharing keys for session " + body.senderKey + "|" + body.sessionId + " with device " + userId + ":" + deviceId);
                        MXOlmInboundGroupSession2 inboundGroupSession = mCrypto.getOlmDevice().getInboundGroupSession(body.sessionId, body.senderKey, body.roomId);
                        Map<String, Object> payloadJson = new HashMap<>();
                        payloadJson.put("type", CryptoEvent.EVENT_TYPE_FORWARDED_ROOM_KEY);
                        payloadJson.put("content", inboundGroupSession.exportKeys());
                        EncryptedMessage encodedPayload = mCrypto.encryptMessage(payloadJson, Arrays.asList(deviceInfo));
                        MXUsersDevicesMap<Object> sendToDeviceMap = new MXUsersDevicesMap<>();
                        sendToDeviceMap.setObject(encodedPayload, userId, deviceId);
                        Log.d(LOG_TAG, "## shareKeysWithDevice() : sending to " + userId + ":" + deviceId);
                        mCrypto.getCryptoRestClient().sendToDevice(CryptoEvent.EVENT_TYPE_MESSAGE_ENCRYPTED, sendToDeviceMap, new ApiCallback<Void>() {

                            @Override
                            public void onSuccess(Void info) {
                                Log.d(LOG_TAG, "## shareKeysWithDevice() : sent to " + userId + ":" + deviceId);
                            }

                            @Override
                            public void onNetworkError(Exception e) {
                                Log.e(LOG_TAG, "## shareKeysWithDevice() : sendToDevice " + userId + ":" + deviceId + " failed " + e.getMessage(), e);
                            }

                            @Override
                            public void onMatrixError(MatrixError e) {
                                Log.e(LOG_TAG, "## shareKeysWithDevice() : sendToDevice " + userId + ":" + deviceId + " failed " + e.getMessage());
                            }

                            @Override
                            public void onUnexpectedError(Exception e) {
                                Log.e(LOG_TAG, "## shareKeysWithDevice() : sendToDevice " + userId + ":" + deviceId + " failed " + e.getMessage(), e);
                            }
                        });
                    }

                    @Override
                    public void onNetworkError(Exception e) {
                        Log.e(LOG_TAG, "## shareKeysWithDevice() : ensureOlmSessionsForDevices " + userId + ":" + deviceId + " failed " + e.getMessage(), e);
                    }

                    @Override
                    public void onMatrixError(MatrixError e) {
                        Log.e(LOG_TAG, "## shareKeysWithDevice() : ensureOlmSessionsForDevices " + userId + ":" + deviceId + " failed " + e.getMessage());
                    }

                    @Override
                    public void onUnexpectedError(Exception e) {
                        Log.e(LOG_TAG, "## shareKeysWithDevice() : ensureOlmSessionsForDevices " + userId + ":" + deviceId + " failed " + e.getMessage(), e);
                    }
                });
            } else {
                Log.e(LOG_TAG, "## shareKeysWithDevice() : ensureOlmSessionsForDevices " + userId + ":" + deviceId + " not found");
            }
        }

        @Override
        public void onNetworkError(Exception e) {
            Log.e(LOG_TAG, "## shareKeysWithDevice() : downloadKeys " + userId + " failed " + e.getMessage(), e);
        }

        @Override
        public void onMatrixError(MatrixError e) {
            Log.e(LOG_TAG, "## shareKeysWithDevice() : downloadKeys " + userId + " failed " + e.getMessage());
        }

        @Override
        public void onUnexpectedError(Exception e) {
            Log.e(LOG_TAG, "## shareKeysWithDevice() : downloadKeys " + userId + " failed " + e.getMessage(), e);
        }
    });
}