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

Example 71 with Event

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

the class EventTimeline method storeLiveRoomEvent.

/**
 * Store a live room event.
 *
 * @param event                   The event to be stored.
 * @param checkRedactedStateEvent true to check if this event redacts a state event
 */
private void storeLiveRoomEvent(Event event, boolean checkRedactedStateEvent) {
    boolean store = false;
    String myUserId = mDataHandler.getCredentials().userId;
    if (Event.EVENT_TYPE_REDACTION.equals(event.getType())) {
        if (event.getRedacts() != null) {
            Event eventToPrune = mStore.getEvent(event.getRedacts(), event.roomId);
            // when an event is redacted, some fields must be kept.
            if (null != eventToPrune) {
                store = true;
                // remove expected keys
                eventToPrune.prune(event);
                // store the prune event
                storeEvent(eventToPrune);
                // store the redaction event too (for the read markers management)
                storeEvent(event);
                // or the redacted event is received with roomSync.timeline.limited
                if (checkRedactedStateEvent && eventToPrune.stateKey != null) {
                    checkStateEventRedaction(event);
                }
                // search the latest displayable event
                // to replace the summary text
                ArrayList<Event> events = new ArrayList<>(mStore.getRoomMessages(event.roomId));
                for (int index = events.size() - 1; index >= 0; index--) {
                    Event anEvent = events.get(index);
                    if (RoomSummary.isSupportedEvent(anEvent)) {
                        // Decrypt event if necessary
                        if (TextUtils.equals(anEvent.getType(), Event.EVENT_TYPE_MESSAGE_ENCRYPTED)) {
                            if (null != mDataHandler.getCrypto()) {
                                mDataHandler.decryptEvent(anEvent, getTimelineId());
                            }
                        }
                        EventDisplay eventDisplay = new EventDisplay(mStore.getContext(), anEvent, mState);
                        // ensure that message can be displayed
                        if (!TextUtils.isEmpty(eventDisplay.getTextualDisplay())) {
                            event = anEvent;
                            break;
                        }
                    }
                }
            } else {
                // or the redacted event is received with roomSync.timeline.limited
                if (checkRedactedStateEvent) {
                    checkStateEventRedaction(event);
                }
            }
        }
    } else {
        // the candidate events are not stored.
        store = !event.isCallEvent() || !Event.EVENT_TYPE_CALL_CANDIDATES.equals(event.getType());
        // if the user leaves a room,
        if (Event.EVENT_TYPE_STATE_ROOM_MEMBER.equals(event.getType()) && myUserId.equals(event.stateKey)) {
            String membership = event.getContent().getAsJsonObject().getAsJsonPrimitive("membership").getAsString();
            if (RoomMember.MEMBERSHIP_LEAVE.equals(membership) || RoomMember.MEMBERSHIP_BAN.equals(membership)) {
                store = mIsHistorical;
            // delete the room and warn the listener of the leave event only at the end of the events chunk processing
            }
        }
    }
    if (store) {
        storeEvent(event);
    }
    // warn the listener that a new room has been created
    if (Event.EVENT_TYPE_STATE_ROOM_CREATE.equals(event.getType())) {
        mDataHandler.onNewRoom(event.roomId);
    }
    // warn the listeners that a room has been joined
    if (Event.EVENT_TYPE_STATE_ROOM_MEMBER.equals(event.getType()) && myUserId.equals(event.stateKey)) {
        String membership = event.getContent().getAsJsonObject().getAsJsonPrimitive("membership").getAsString();
        if (RoomMember.MEMBERSHIP_JOIN.equals(membership)) {
            mDataHandler.onJoinRoom(event.roomId);
        } else if (RoomMember.MEMBERSHIP_INVITE.equals(membership)) {
            mDataHandler.onNewRoom(event.roomId);
        }
    }
}

Example 72 with Event

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

the class Room method addEventListener.

// ==============================================================================================================
// Room events dispatcher
// ==============================================================================================================
/**
 * Add an event listener to this room. Only events relative to the room will come down.
 *
 * @param eventListener the event listener to add
 */
public void addEventListener(final IMXEventListener eventListener) {
    // sanity check
    if (null == eventListener) {
        Log.e(LOG_TAG, "addEventListener : eventListener is null");
        return;
    }
    // GA crash : should never happen but got it.
    if (null == mDataHandler) {
        Log.e(LOG_TAG, "addEventListener : mDataHandler is null");
        return;
    }
    // Create a global listener that we'll add to the data handler
    IMXEventListener globalListener = new MXEventListener() {

        @Override
        public void onPresenceUpdate(Event event, User user) {
            // Only pass event through if the user is a member of the room
            if (getMember(user.user_id) != null) {
                try {
                    eventListener.onPresenceUpdate(event, user);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onPresenceUpdate exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            // Filter out events for other rooms and events while we are joining (before the room is ready)
            if (TextUtils.equals(getRoomId(), event.roomId) && mIsReady) {
                try {
                    eventListener.onLiveEvent(event, roomState);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onLiveEvent exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onLiveEventsChunkProcessed(String fromToken, String toToken) {
            try {
                eventListener.onLiveEventsChunkProcessed(fromToken, toToken);
            } catch (Exception e) {
                Log.e(LOG_TAG, "onLiveEventsChunkProcessed exception " + e.getMessage());
            }
        }

        @Override
        public void onEventSentStateUpdated(Event event) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), event.roomId)) {
                try {
                    eventListener.onEventSentStateUpdated(event);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onEventSentStateUpdated exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onEventDecrypted(Event event) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), event.roomId)) {
                try {
                    eventListener.onEventDecrypted(event);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onDecryptedEvent exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onEventSent(final Event event, final String prevEventId) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), event.roomId)) {
                try {
                    eventListener.onEventSent(event, prevEventId);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onEventSent exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onRoomInitialSyncComplete(String roomId) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), roomId)) {
                try {
                    eventListener.onRoomInitialSyncComplete(roomId);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onRoomInitialSyncComplete exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onRoomInternalUpdate(String roomId) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), roomId)) {
                try {
                    eventListener.onRoomInternalUpdate(roomId);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onRoomInternalUpdate exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onNotificationCountUpdate(String roomId) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), roomId)) {
                try {
                    eventListener.onNotificationCountUpdate(roomId);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onNotificationCountUpdate exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onNewRoom(String roomId) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), roomId)) {
                try {
                    eventListener.onNewRoom(roomId);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onNewRoom exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onJoinRoom(String roomId) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), roomId)) {
                try {
                    eventListener.onJoinRoom(roomId);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onJoinRoom exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onReceiptEvent(String roomId, List<String> senderIds) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), roomId)) {
                try {
                    eventListener.onReceiptEvent(roomId, senderIds);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onReceiptEvent exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onRoomTagEvent(String roomId) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), roomId)) {
                try {
                    eventListener.onRoomTagEvent(roomId);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onRoomTagEvent exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onReadMarkerEvent(String roomId) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), roomId)) {
                try {
                    eventListener.onReadMarkerEvent(roomId);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onReadMarkerEvent exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onRoomFlush(String roomId) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), roomId)) {
                try {
                    eventListener.onRoomFlush(roomId);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onRoomFlush exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onLeaveRoom(String roomId) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), roomId)) {
                try {
                    eventListener.onLeaveRoom(roomId);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onLeaveRoom exception " + e.getMessage());
                }
            }
        }

        @Override
        public void onRoomKick(String roomId) {
            // Filter out events for other rooms
            if (TextUtils.equals(getRoomId(), roomId)) {
                try {
                    eventListener.onRoomKick(roomId);
                } catch (Exception e) {
                    Log.e(LOG_TAG, "onRoomKick exception " + e.getMessage());
                }
            }
        }
    };
    mEventListeners.put(eventListener, globalListener);
    // GA crash
    if (null != mDataHandler) {
        mDataHandler.addListener(globalListener);
    }
}

Example 73 with Event

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

the class Room method handleAccountDataEvents.

// ================================================================================
// Account data management
// ================================================================================
/**
 * Handle private user data events.
 *
 * @param accountDataEvents the account events.
 */
private void handleAccountDataEvents(List<Event> accountDataEvents) {
    if ((null != accountDataEvents) && (accountDataEvents.size() > 0)) {
        // manage the account events
        for (Event accountDataEvent : accountDataEvents) {
            String eventType = accountDataEvent.getType();
            if (eventType.equals(Event.EVENT_TYPE_READ_MARKER)) {
                RoomSummary summary = (null != getStore()) ? getStore().getSummary(getRoomId()) : null;
                if (null != summary) {
                    Event event = JsonUtils.toEvent(accountDataEvent.getContent());
                    if (null != event && !TextUtils.equals(event.eventId, summary.getReadMarkerEventId())) {
                        Log.d(LOG_TAG, "## handleAccountDataEvents() : update the read marker to " + event.eventId + " in room " + getRoomId());
                        if (TextUtils.isEmpty(event.eventId)) {
                            Log.e(LOG_TAG, "## handleAccountDataEvents() : null event id " + accountDataEvent.getContent());
                        }
                        summary.setReadMarkerEventId(event.eventId);
                        getStore().flushSummary(summary);
                        mDataHandler.onReadMarkerEvent(getRoomId());
                    }
                }
            } else {
                try {
                    mAccountData.handleTagEvent(accountDataEvent);
                    if (accountDataEvent.getType().equals(Event.EVENT_TYPE_TAGS)) {
                        mDataHandler.onRoomTagEvent(getRoomId());
                    }
                    if (accountDataEvent.getType().equals(Event.EVENT_TYPE_URL_PREVIEW)) {
                        JsonObject jsonObject = accountDataEvent.getContentAsJsonObject();
                        if (jsonObject.has(AccountDataRestClient.ACCOUNT_DATA_KEY_URL_PREVIEW_DISABLE)) {
                            boolean disabled = jsonObject.get(AccountDataRestClient.ACCOUNT_DATA_KEY_URL_PREVIEW_DISABLE).getAsBoolean();
                            Set<String> roomIdsWithoutURLPreview = mDataHandler.getStore().getRoomsWithoutURLPreviews();
                            if (disabled) {
                                roomIdsWithoutURLPreview.add(getRoomId());
                            } else {
                                roomIdsWithoutURLPreview.remove(getRoomId());
                            }
                            mDataHandler.getStore().setRoomsWithoutURLPreview(roomIdsWithoutURLPreview);
                        }
                    }
                } catch (Exception e) {
                    Log.e(LOG_TAG, "## handleAccountDataEvents() : room " + getRoomId() + " failed " + e.getMessage());
                }
            }
        }
        if (null != getStore()) {
            getStore().storeAccountData(getRoomId(), mAccountData);
        }
    }
}