Swift/Controllers/XMPPEvents/EventController.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

/*
 * Copyright (c) 2010-2016 Isode Limited.
 * All rights reserved.
 * See the COPYING file for more information.
 */

#include <Swift/Controllers/XMPPEvents/EventController.h>

#include <algorithm>

#include <boost/bind.hpp>
#include <boost/numeric/conversion/cast.hpp>

#include <Swiften/Base/foreach.h>

#include <Swift/Controllers/XMPPEvents/ErrorEvent.h>
#include <Swift/Controllers/XMPPEvents/IncomingFileTransferEvent.h>
#include <Swift/Controllers/XMPPEvents/MUCInviteEvent.h>
#include <Swift/Controllers/XMPPEvents/MessageEvent.h>
#include <Swift/Controllers/XMPPEvents/SubscriptionRequestEvent.h>

namespace Swift {

EventController::EventController() {
}

EventController::~EventController() {
    foreach(std::shared_ptr<StanzaEvent> event, events_) {
        event->onConclusion.disconnect(boost::bind(&EventController::handleEventConcluded, this, event));
    }
}

void EventController::handleIncomingEvent(std::shared_ptr<StanzaEvent> sourceEvent) {
    std::shared_ptr<MessageEvent> messageEvent = std::dynamic_pointer_cast<MessageEvent>(sourceEvent);
    std::shared_ptr<SubscriptionRequestEvent> subscriptionEvent = std::dynamic_pointer_cast<SubscriptionRequestEvent>(sourceEvent);
    std::shared_ptr<ErrorEvent> errorEvent = std::dynamic_pointer_cast<ErrorEvent>(sourceEvent);
    std::shared_ptr<MUCInviteEvent> mucInviteEvent = std::dynamic_pointer_cast<MUCInviteEvent>(sourceEvent);
    std::shared_ptr<IncomingFileTransferEvent> incomingFileTransferEvent = std::dynamic_pointer_cast<IncomingFileTransferEvent>(sourceEvent);

    /* If it's a duplicate subscription request, remove the previous request first */
    if (subscriptionEvent) {
        EventList existingEvents(events_);
        foreach(std::shared_ptr<StanzaEvent> existingEvent, existingEvents) {
            std::shared_ptr<SubscriptionRequestEvent> existingSubscriptionEvent = std::dynamic_pointer_cast<SubscriptionRequestEvent>(existingEvent);
            if (existingSubscriptionEvent) {
                if (existingSubscriptionEvent->getJID() == subscriptionEvent->getJID()) {
                    existingEvent->conclude();
                }
            }
        }
    }

    if ((messageEvent && messageEvent->isReadable()) || subscriptionEvent || errorEvent || mucInviteEvent || incomingFileTransferEvent) {
        events_.push_back(sourceEvent);
        sourceEvent->onConclusion.connect(boost::bind(&EventController::handleEventConcluded, this, sourceEvent));
        onEventQueueLengthChange(boost::numeric_cast<int>(events_.size()));
        onEventQueueEventAdded(sourceEvent);
        if (sourceEvent->getConcluded()) {
            handleEventConcluded(sourceEvent);
        }
    }
}

void EventController::handleEventConcluded(std::shared_ptr<StanzaEvent> event) {
    event->onConclusion.disconnect(boost::bind(&EventController::handleEventConcluded, this, event));
    events_.erase(std::remove(events_.begin(), events_.end(), event), events_.end());
    onEventQueueLengthChange(boost::numeric_cast<int>(events_.size()));
}

void EventController::disconnectAll() {
    onEventQueueLengthChange.disconnect_all_slots();
    onEventQueueEventAdded.disconnect_all_slots();
}

void EventController::clear() {
    events_.clear();
    onEventQueueLengthChange(0);
}

}