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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
/*
@VaadinApache2LicenseForJavaFiles@
*/
package com.vaadin.terminal.gwt.client.ui;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import com.google.gwt.event.shared.GwtEvent;
import com.google.gwt.event.shared.HandlerManager;
import com.google.web.bindery.event.shared.HandlerRegistration;
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.ServerConnector;
import com.vaadin.terminal.gwt.client.Util;
import com.vaadin.terminal.gwt.client.VConsole;
import com.vaadin.terminal.gwt.client.communication.ClientRpc;
import com.vaadin.terminal.gwt.client.communication.StateChangeEvent;
import com.vaadin.terminal.gwt.client.communication.StateChangeEvent.StateChangeHandler;
/**
* An abstract implementation of Connector.
*
* @author Vaadin Ltd
* @version @VERSION@
* @since 7.0.0
*
*/
public abstract class AbstractConnector implements ServerConnector,
StateChangeHandler {
private ApplicationConnection connection;
private String id;
private HandlerManager handlerManager;
private Map<String, Collection<ClientRpc>> rpcImplementations;
private final boolean debugLogging = false;
/*
* (non-Javadoc)
*
* @see com.vaadin.terminal.gwt.client.VPaintable#getConnection()
*/
public final ApplicationConnection getConnection() {
return connection;
}
/*
* (non-Javadoc)
*
* @see com.vaadin.terminal.gwt.client.Connector#getId()
*/
public String getConnectorId() {
return id;
}
/**
* Called once by the framework to initialize the connector.
* <p>
* Note that the shared state is not yet available when this method is
* called.
* <p>
* Connector classes should override {@link #init()} instead of this method.
*/
public final void doInit(String connectorId,
ApplicationConnection connection) {
this.connection = connection;
id = connectorId;
addStateChangeHandler(this);
init();
}
/**
* Called when the connector has been initialized. Override this method to
* perform initialization of the connector.
*/
// FIXME: It might make sense to make this abstract to force users to
// use init instead of constructor, where connection and id has not yet been
// set.
protected void init() {
}
/**
* Registers an implementation for a server to client RPC interface.
*
* Multiple registrations can be made for a single interface, in which case
* all of them receive corresponding RPC calls.
*
* @param rpcInterface
* RPC interface
* @param implementation
* implementation that should receive RPC calls
* @param <T>
* The type of the RPC interface that is being registered
*/
protected <T extends ClientRpc> void registerRpc(Class<T> rpcInterface,
T implementation) {
String rpcInterfaceId = rpcInterface.getName().replaceAll("\\$", ".");
if (null == rpcImplementations) {
rpcImplementations = new HashMap<String, Collection<ClientRpc>>();
}
if (null == rpcImplementations.get(rpcInterfaceId)) {
rpcImplementations.put(rpcInterfaceId, new ArrayList<ClientRpc>());
}
rpcImplementations.get(rpcInterfaceId).add(implementation);
}
/**
* Unregisters an implementation for a server to client RPC interface.
*
* @param rpcInterface
* RPC interface
* @param implementation
* implementation to unregister
*/
protected <T extends ClientRpc> void unregisterRpc(Class<T> rpcInterface,
T implementation) {
String rpcInterfaceId = rpcInterface.getName().replaceAll("\\$", ".");
if (null != rpcImplementations
&& null != rpcImplementations.get(rpcInterfaceId)) {
rpcImplementations.get(rpcInterfaceId).remove(implementation);
}
}
public <T extends ClientRpc> Collection<T> getRpcImplementations(
String rpcInterfaceId) {
if (null == rpcImplementations) {
return Collections.emptyList();
}
return (Collection<T>) rpcImplementations.get(rpcInterfaceId);
}
/*
* (non-Javadoc)
*
* @see com.vaadin.terminal.gwt.client.Connector#isConnectorEnabled()
*/
public boolean isConnectorEnabled() {
// Client side can always receive message from the server
return true;
}
public void fireEvent(GwtEvent<?> event) {
if (handlerManager != null) {
handlerManager.fireEvent(event);
}
}
protected HandlerManager ensureHandlerManager() {
if (handlerManager == null) {
handlerManager = new HandlerManager(this);
}
return handlerManager;
}
public HandlerRegistration addStateChangeHandler(StateChangeHandler handler) {
return ensureHandlerManager()
.addHandler(StateChangeEvent.TYPE, handler);
}
public void onStateChanged(StateChangeEvent stateChangeEvent) {
if (debugLogging) {
VConsole.log("State change event for "
+ Util.getConnectorString(stateChangeEvent.getConnector())
+ " received by " + Util.getConnectorString(this));
}
}
/*
* (non-Javadoc)
*
* @see com.vaadin.terminal.gwt.client.ServerConnector#onUnregister()
*/
public void onUnregister() {
if (debugLogging) {
VConsole.log("Unregistered connector "
+ Util.getConnectorString(this));
}
}
}
|
