blob: 95f59d815a1f6ea90b04fe93d40c49c9812dc96a (
plain)
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
/*
* Copyright (c) 2010, Isode Limited, London, England.
* All rights reserved.
*/
/*
* Copyright (c) 2010, Remko Tron?on.
* All rights reserved.
*/
package com.isode.stroke.client;
import com.isode.stroke.base.Error;
import com.isode.stroke.elements.IQ;
import com.isode.stroke.elements.Message;
import com.isode.stroke.elements.Presence;
import com.isode.stroke.elements.Stanza;
import com.isode.stroke.signals.SignalConnection;
import com.isode.stroke.signals.Slot;
import com.isode.stroke.signals.Slot1;
import java.util.logging.Logger;
/**
* StanzaChannel implementation around a ClientSession.
*/
public class ClientSessionStanzaChannel extends StanzaChannel {
private final IDGenerator idGenerator = new IDGenerator();
private ClientSession session;
private static final Logger logger_ = Logger.getLogger(ClientSessionStanzaChannel.class.getName());
private SignalConnection sessionInitializedConnection;
private SignalConnection sessionFinishedConnection;
private SignalConnection sessionStanzaReceivedConnection;
private SignalConnection sessionStanzaAckedConnection;
public void setSession(final ClientSession session) {
assert this.session == null;
this.session = session;
sessionInitializedConnection = session.onInitialized.connect(new Slot() {
public void call() {
handleSessionInitialized();
}
});
sessionFinishedConnection = session.onFinished.connect(new Slot1<Error>() {
public void call(final Error p1) {
handleSessionFinished(p1);
}
});
sessionStanzaReceivedConnection = session.onStanzaReceived.connect(new Slot1<Stanza>() {
public void call(final Stanza p1) {
handleStanza(p1);
}
});
sessionStanzaAckedConnection = session.onStanzaAcked.connect(new Slot1<Stanza>() {
public void call(final Stanza p1) {
handleStanzaAcked(p1);
}
});
}
public void sendIQ(final IQ iq) {
send(iq);
}
public void sendMessage(final Message message) {
send(message);
}
public void sendPresence(final Presence presence) {
send(presence);
}
public boolean getStreamManagementEnabled() {
if (session != null) {
return session.getStreamManagementEnabled();
}
return false;
}
public boolean isAvailable() {
return session != null && ClientSession.State.Initialized.equals(session.getState());
}
public String getNewIQID() {
return idGenerator.generateID();
}
private void send(final Stanza stanza) {
if (!isAvailable()) {
logger_.warning("Warning: Client: Trying to send a stanza while disconnected.");
return;
}
session.sendStanza(stanza);
}
private void handleSessionFinished(final Error error) { // NOPMD, ignore that Error isn't used.
sessionFinishedConnection.disconnect();
sessionStanzaReceivedConnection.disconnect();
sessionStanzaAckedConnection.disconnect();
sessionInitializedConnection.disconnect();
session = null;
onAvailableChanged.emit(false);
}
private void handleStanza(final Stanza stanza) {
if (stanza instanceof Message) {
onMessageReceived.emit((Message)stanza);
}
if (stanza instanceof Presence) {
onPresenceReceived.emit((Presence)stanza);
}
if (stanza instanceof IQ) {
onIQReceived.emit((IQ)stanza);
}
}
private void handleStanzaAcked(final Stanza stanza) {
onStanzaAcked.emit(stanza);
}
private void handleSessionInitialized() {
onAvailableChanged.emit(true);
}
}
|
Swift