blob: 0aa024f7ab95423ed83d1dfe790639290c97db40 (
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
127
128
129
130
131
132
133
134
135
136
137
|
/*
* Copyright (c) 2010-2014, 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 com.isode.stroke.tls.Certificate;
import java.util.ArrayList;
import java.util.List;
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 List<Certificate> getPeerCertificateChain() {
if (session != null) {
return session.getPeerCertificateChain();
}
return new ArrayList<Certificate>();
}
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