1 | /* |
---|
2 | * Jeti, a Java Jabber client, Copyright (C) 2001 E.S. de Boer |
---|
3 | * |
---|
4 | * This program is free software; you can redistribute it and/or modify |
---|
5 | * it under the terms of the GNU General Public License as published by |
---|
6 | * the Free Software Foundation; either version 2 of the License, or |
---|
7 | * (at your option) any later version. |
---|
8 | * |
---|
9 | * This program is distributed in the hope that it will be useful, |
---|
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
---|
12 | * GNU General Public License for more details. |
---|
13 | * |
---|
14 | * You should have received a copy of the GNU General Public License |
---|
15 | * along with this program; if not, write to the Free Software |
---|
16 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
---|
17 | * |
---|
18 | * For questions, comments etc, |
---|
19 | * use the website at http://jeti.jabberstudio.org |
---|
20 | * or mail me at jeti@jabberstudio.org |
---|
21 | * created 2001 |
---|
22 | */ |
---|
23 | |
---|
24 | package nu.fw.jeti.backend.roster; |
---|
25 | |
---|
26 | import java.lang.reflect.InvocationTargetException; |
---|
27 | import java.util.HashMap; |
---|
28 | import java.util.Iterator; |
---|
29 | import java.util.List; |
---|
30 | import java.util.Map; |
---|
31 | |
---|
32 | import javax.swing.SwingUtilities; |
---|
33 | |
---|
34 | import nu.fw.jeti.events.CompleteRosterListener; |
---|
35 | import nu.fw.jeti.events.PresenceListener; |
---|
36 | import nu.fw.jeti.events.RosterListener; |
---|
37 | import nu.fw.jeti.jabber.Backend; |
---|
38 | import nu.fw.jeti.jabber.JID; |
---|
39 | import nu.fw.jeti.jabber.JIDStatus; |
---|
40 | import nu.fw.jeti.jabber.elements.IQXRoster; |
---|
41 | import nu.fw.jeti.jabber.elements.InfoQuery; |
---|
42 | import nu.fw.jeti.jabber.elements.Presence; |
---|
43 | import nu.fw.jeti.jabber.elements.RosterItem; |
---|
44 | import nu.fw.jeti.util.I18N; |
---|
45 | import nu.fw.jeti.util.Preferences; |
---|
46 | |
---|
47 | /** |
---|
48 | * Class that controls the Roster. JIDS whithout a username |
---|
49 | * are assumed to be a transport/server and are transfered to Server. |
---|
50 | * The items in the roster are sorted stored. |
---|
51 | * Changes in the roster are broadcasted using the RosterListener |
---|
52 | * @see Server |
---|
53 | * @see RosterListener |
---|
54 | * @author E.S. de Boer |
---|
55 | * @version 1.0 |
---|
56 | */ |
---|
57 | |
---|
58 | public class Roster implements CompleteRosterListener, PresenceListener |
---|
59 | { |
---|
60 | private JIDStatusTree jidTree; |
---|
61 | private static Map jidStatussen = new HashMap(32); //default 20 different?;//fast access to tree |
---|
62 | private Backend backend; |
---|
63 | private boolean first; //server hack |
---|
64 | private Server server; |
---|
65 | |
---|
66 | public Roster(Backend backend, Server server) |
---|
67 | { |
---|
68 | this.server = server; |
---|
69 | this.backend = backend; |
---|
70 | backend.addListener(CompleteRosterListener.class, this); |
---|
71 | backend.addListener(PresenceListener.class, this); |
---|
72 | } |
---|
73 | |
---|
74 | //-------------------roster events--------------------------------------\\ |
---|
75 | public void rosterReceived(final InfoQuery infoquery, final IQXRoster roster) |
---|
76 | { |
---|
77 | Runnable updateAComponent = new Runnable() { |
---|
78 | public void run() |
---|
79 | { |
---|
80 | if (infoquery.getType().equals("result")) |
---|
81 | { |
---|
82 | //complete new roster |
---|
83 | completeRoster(roster); |
---|
84 | } |
---|
85 | else if (infoquery.getType().equals("set")) |
---|
86 | { |
---|
87 | //add result |
---|
88 | for (Iterator i = roster.getItems(); i.hasNext();) |
---|
89 | { |
---|
90 | RosterItem item = (RosterItem) i.next(); |
---|
91 | JID jid = item.getJID(); |
---|
92 | String nick = item.getName(); |
---|
93 | if (nick == null) nick = jid.toString(); |
---|
94 | NormalJIDStatus oldJIDStatus = (NormalJIDStatus) jidStatussen.get(jid); |
---|
95 | if ("remove".equals(item.getSubscription())) |
---|
96 | { |
---|
97 | removeFromRoster(oldJIDStatus, item, jid); |
---|
98 | } |
---|
99 | else if (oldJIDStatus == null) |
---|
100 | { |
---|
101 | //group must be present (no unfiled) except when server |
---|
102 | if (item.getGroups() != null || jid.getUser() == null) addToRoster(nick, item, jid); |
---|
103 | } |
---|
104 | else |
---|
105 | { |
---|
106 | changeItem(oldJIDStatus, nick, item, jid); |
---|
107 | } |
---|
108 | } |
---|
109 | } |
---|
110 | } |
---|
111 | }; |
---|
112 | try |
---|
113 | { |
---|
114 | SwingUtilities.invokeAndWait(updateAComponent); |
---|
115 | } catch (InterruptedException e) |
---|
116 | { |
---|
117 | e.printStackTrace(); |
---|
118 | } catch (InvocationTargetException e) |
---|
119 | { |
---|
120 | e.printStackTrace(); |
---|
121 | } |
---|
122 | } |
---|
123 | |
---|
124 | private void completeRoster(IQXRoster roster) |
---|
125 | { |
---|
126 | //add complete roster |
---|
127 | //System.out.println("result"); |
---|
128 | jidStatussen = new HashMap(32); //default 20 different? |
---|
129 | server.addJIDStatussen(jidStatussen); |
---|
130 | jidTree = new JIDStatusTree(); |
---|
131 | server.clear(); |
---|
132 | for (Iterator i = roster.getItems(); i.hasNext();) |
---|
133 | { |
---|
134 | RosterItem item = (RosterItem) i.next(); |
---|
135 | JIDStatus jidStatus = new NormalJIDStatus(item); |
---|
136 | jidStatussen.put(item.getJID(), jidStatus); |
---|
137 | if (item.getJID().getUser() == null) |
---|
138 | { |
---|
139 | //server /transport |
---|
140 | server.addServerNoFire(jidStatus); |
---|
141 | } |
---|
142 | else |
---|
143 | { |
---|
144 | if (item.getGroups() == null) |
---|
145 | addJIDStatus(I18N.gettext("main.main.roster.Unfiled"), jidStatus); |
---|
146 | else |
---|
147 | { |
---|
148 | for (Iterator j = item.getGroups().iterator(); j.hasNext();) |
---|
149 | { |
---|
150 | //new jidstatus per group? |
---|
151 | addJIDStatus((String) j.next(), jidStatus); |
---|
152 | } |
---|
153 | } |
---|
154 | } |
---|
155 | } |
---|
156 | backend.rosterLoaded(); |
---|
157 | server.fire(); |
---|
158 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
159 | { |
---|
160 | ((RosterListener) j.next()).rosterReplaced(jidTree); |
---|
161 | } |
---|
162 | } |
---|
163 | |
---|
164 | private void removeFromRoster(NormalJIDStatus oldJIDStatus, RosterItem item, JID jid) |
---|
165 | { |
---|
166 | if (oldJIDStatus == null) |
---|
167 | return; //jidstatus unknown |
---|
168 | String oldNick = oldJIDStatus.getNick(); |
---|
169 | if (item.getJID().getUser() == null) |
---|
170 | { |
---|
171 | //server /transport |
---|
172 | server.removeServer(oldNick, oldJIDStatus); |
---|
173 | } |
---|
174 | else |
---|
175 | { |
---|
176 | if (oldJIDStatus.groupCount() < 1) |
---|
177 | { |
---|
178 | //unknown group |
---|
179 | removeJIDStatus(I18N.gettext("main.main.roster.Unfiled"), oldNick, oldJIDStatus); |
---|
180 | } |
---|
181 | else |
---|
182 | { |
---|
183 | //known groups |
---|
184 | for (Iterator j = oldJIDStatus.getGroups(); j.hasNext();) |
---|
185 | { |
---|
186 | //remove |
---|
187 | removeJIDStatus((String) j.next(), oldNick, oldJIDStatus); |
---|
188 | } |
---|
189 | } |
---|
190 | } |
---|
191 | jidStatussen.remove(jid); //remove from cache |
---|
192 | } |
---|
193 | |
---|
194 | private void addToRoster(String nick, RosterItem item, JID jid) |
---|
195 | { |
---|
196 | if (!first && (item.getGroups() == null || item.getName() == null)) |
---|
197 | { |
---|
198 | //server sends first a rosterset without nickname and groups |
---|
199 | //we don't need that because it generates a new group or new nicknames |
---|
200 | first = true; //first time sended |
---|
201 | return; |
---|
202 | } |
---|
203 | first = false; |
---|
204 | //System.out.println("addnew"); |
---|
205 | NormalJIDStatus jidStatus = new NormalJIDStatus(item); |
---|
206 | jidStatussen.put(jid, jidStatus); |
---|
207 | if (jid.getUser() == null) |
---|
208 | { |
---|
209 | //server /transport |
---|
210 | server.addServer(nick, jidStatus); |
---|
211 | } |
---|
212 | else if (item.getGroups() == null) |
---|
213 | { |
---|
214 | //no groups only when complete roster |
---|
215 | addJIDStatusFire(I18N.gettext("main.main.roster.Unfiled"), nick, jidStatus); |
---|
216 | } |
---|
217 | else |
---|
218 | { |
---|
219 | for (Iterator j = item.getGroups().iterator(); j.hasNext();) |
---|
220 | { |
---|
221 | //new jidstatus per group? |
---|
222 | addJIDStatusFire((String) j.next(), nick, jidStatus); |
---|
223 | } |
---|
224 | } |
---|
225 | } |
---|
226 | |
---|
227 | private void changeItem(NormalJIDStatus oldJIDStatus, String nick, RosterItem item, JID jid) |
---|
228 | { |
---|
229 | //group nickname or other change to rosteritem |
---|
230 | if (!nick.equals(oldJIDStatus.getNick())) |
---|
231 | { |
---|
232 | //nick changes |
---|
233 | nickChanges(oldJIDStatus, nick, item, jid); |
---|
234 | } |
---|
235 | if (jid.getUser() == null) //no else because change nick & change groups could be at same time |
---|
236 | { |
---|
237 | //server doesn't care about groups |
---|
238 | oldJIDStatus.update(item); |
---|
239 | } |
---|
240 | else if (item.getGroups() == null) |
---|
241 | { |
---|
242 | //heeft 0 groups |
---|
243 | if (oldJIDStatus.groupCount() < 1) |
---|
244 | oldJIDStatus.update(item); //had 0 heeft 0 overbodig? |
---|
245 | else |
---|
246 | { |
---|
247 | if (!oldJIDStatus.isGroupPresent(I18N.gettext("main.main.roster.Unfiled"))) |
---|
248 | { |
---|
249 | //heeft 0 had meer |
---|
250 | for (Iterator j = oldJIDStatus.getGroups(); j.hasNext();) |
---|
251 | { |
---|
252 | //remove |
---|
253 | removeJIDStatus((String) j.next(), nick, oldJIDStatus); |
---|
254 | } |
---|
255 | addJIDStatusFire(I18N.gettext("main.main.roster.Unfiled"), nick, oldJIDStatus); //add to unfiled |
---|
256 | oldJIDStatus.update(item); |
---|
257 | } |
---|
258 | } |
---|
259 | } |
---|
260 | else |
---|
261 | { |
---|
262 | changeGroups(oldJIDStatus, nick, item); |
---|
263 | } |
---|
264 | } |
---|
265 | |
---|
266 | private void nickChanges(NormalJIDStatus oldJIDStatus, String nick, RosterItem item, JID jid) |
---|
267 | { |
---|
268 | //nickname changed |
---|
269 | String oldNick = oldJIDStatus.getNick(); |
---|
270 | if (jid.getUser() == null) |
---|
271 | { |
---|
272 | //server /transport |
---|
273 | server.removeServer(oldNick, oldJIDStatus); |
---|
274 | oldJIDStatus.update(item); |
---|
275 | server.addServer(nick, oldJIDStatus); |
---|
276 | } |
---|
277 | else |
---|
278 | { |
---|
279 | //nickname is different so new primarys |
---|
280 | //System.out.println("remove old nicknames"); |
---|
281 | //remove old |
---|
282 | if (oldJIDStatus.groupCount() < 1) |
---|
283 | { |
---|
284 | //unknown group |
---|
285 | removeJIDStatus(I18N.gettext("main.main.roster.Unfiled"), oldNick, oldJIDStatus); |
---|
286 | } |
---|
287 | else |
---|
288 | { |
---|
289 | //known groups |
---|
290 | for (Iterator j = oldJIDStatus.getGroups(); j.hasNext();) |
---|
291 | { |
---|
292 | //remove |
---|
293 | removeJIDStatus((String) j.next(), oldNick, oldJIDStatus); |
---|
294 | } |
---|
295 | } |
---|
296 | oldJIDStatus.update(item); |
---|
297 | //addnew |
---|
298 | if (item.getGroups() == null) |
---|
299 | { |
---|
300 | addJIDStatusFire(I18N.gettext("main.main.roster.Unfiled"), nick, oldJIDStatus); |
---|
301 | } |
---|
302 | else |
---|
303 | { |
---|
304 | for (Iterator j = item.getGroups().iterator(); j.hasNext();) |
---|
305 | { |
---|
306 | //new jidstatus per group? |
---|
307 | addJIDStatusFire((String) j.next(), nick, oldJIDStatus); |
---|
308 | } |
---|
309 | } |
---|
310 | } |
---|
311 | |
---|
312 | } |
---|
313 | |
---|
314 | private void changeGroups(NormalJIDStatus oldJIDStatus, String nick, RosterItem item) |
---|
315 | { |
---|
316 | /* |
---|
317 | if(oldJIDStatus.groupCount() < 1)//overbodig?? |
---|
318 | {//had 0 heeft meer |
---|
319 | removeJIDStatus("Unfiled",nick,oldJIDStatus); |
---|
320 | for(Iterator j = item.getGroups().iterator();j.hasNext();) |
---|
321 | {//new jidstatus per group? |
---|
322 | addJIDStatusFire((String) j.next(),nick,oldJIDStatus); |
---|
323 | } |
---|
324 | oldJIDStatus.update(item); |
---|
325 | } |
---|
326 | else |
---|
327 | */ |
---|
328 | //{//heeft x had y |
---|
329 | List oldGroups = oldJIDStatus.getGroupsCopy(); |
---|
330 | for (Iterator j = item.getGroups().iterator(); j.hasNext();) |
---|
331 | { |
---|
332 | //new jidstatus per group? |
---|
333 | String newGroup = (String) j.next(); |
---|
334 | if (oldGroups.contains(newGroup)) |
---|
335 | oldGroups.remove(newGroup); |
---|
336 | else |
---|
337 | addJIDStatusFire(newGroup, nick, oldJIDStatus); |
---|
338 | } |
---|
339 | for (Iterator j = oldGroups.iterator(); j.hasNext();) |
---|
340 | { |
---|
341 | //remove old groups |
---|
342 | removeJIDStatus((String) j.next(), nick, oldJIDStatus); |
---|
343 | } |
---|
344 | oldJIDStatus.update(item); |
---|
345 | //} |
---|
346 | } |
---|
347 | |
---|
348 | //---------------------add //remove //change methods-------------------------------------- |
---|
349 | private void addJIDStatus(String group, JIDStatus jidStatus) |
---|
350 | { |
---|
351 | //add jidstatus for complete roster the roster will be completely refreshed so no fires per jidstatus |
---|
352 | JIDStatusGroup jidGroup = jidTree.getGroup(group); |
---|
353 | PrimaryJIDStatus primary = jidGroup.searchPrimaryJIDStatus(jidStatus.getNick()); |
---|
354 | if (primary == null) |
---|
355 | { |
---|
356 | primary = new PrimaryJIDStatus(jidStatus.getNick(),jidStatus); |
---|
357 | jidGroup.addPrimaryJIDStatus(primary); |
---|
358 | } |
---|
359 | else primary.addJIDStatus(jidStatus); |
---|
360 | //jidGroup.sort(); |
---|
361 | } |
---|
362 | |
---|
363 | private void addJIDStatusFire(String group, String nick, NormalJIDStatus normalJIDStatus) |
---|
364 | { |
---|
365 | // System.out.println("add"); |
---|
366 | JIDStatusGroup jidGroup; |
---|
367 | if (!jidTree.existGroup(group)) |
---|
368 | { |
---|
369 | jidGroup = jidTree.getGroup(group); |
---|
370 | int index = jidTree.indexOfGroup(jidGroup); |
---|
371 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
372 | { |
---|
373 | //fire group make |
---|
374 | ((RosterListener) j.next()).groupAdded(jidGroup, index); |
---|
375 | } |
---|
376 | } |
---|
377 | else jidGroup = jidTree.getGroup(group); |
---|
378 | PrimaryJIDStatus primary = jidGroup.searchPrimaryJIDStatus(nick); |
---|
379 | for (Iterator i = normalJIDStatus.getSecondaryJIDStatussen(); i.hasNext();) |
---|
380 | {//add secondary jidstatussen |
---|
381 | SecondaryJIDStatus jidStatus = (SecondaryJIDStatus) i.next(); |
---|
382 | // bug if primary was offline but now becomes online |
---|
383 | // then odd results so now do things slower but consistent |
---|
384 | //(add is rare so no problem) |
---|
385 | primary = addJIDStatus(nick, jidGroup, primary, jidStatus); |
---|
386 | } |
---|
387 | primary = addJIDStatus(nick, jidGroup, primary, normalJIDStatus); |
---|
388 | primary.updatePresence(normalJIDStatus); |
---|
389 | boolean oldOnline = primary.isOnline(); |
---|
390 | primary.updateOnline(); |
---|
391 | if(!oldOnline && primary.isOnline()) |
---|
392 | {//add online |
---|
393 | jidGroup.addOnline(); |
---|
394 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
395 | { |
---|
396 | ((RosterListener) j.next()).groupUpdated(jidGroup, jidTree.indexOfGroup(jidGroup)); |
---|
397 | } |
---|
398 | } |
---|
399 | |
---|
400 | // {//fire update if changed (faster) |
---|
401 | // int index = jidGroup.indexOfPrimaryJIDStatus(primary); |
---|
402 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
403 | { |
---|
404 | ((RosterListener) j.next()).jidStatussenUpdated(jidGroup,primary); |
---|
405 | //primaryUpdated(jidGroup, primary,index); |
---|
406 | } |
---|
407 | // } |
---|
408 | |
---|
409 | |
---|
410 | /* |
---|
411 | else if(primary.addJIDStatus(jidStatus)) |
---|
412 | { //fire update |
---|
413 | int index = jidGroup.indexOfPrimaryJIDStatus(primary); |
---|
414 | for(Iterator j = backend.getListeners(RosterListener.class);j.hasNext();) |
---|
415 | { |
---|
416 | ((RosterListener)j.next()).primaryUpdated(jidGroup,primary,index); |
---|
417 | } |
---|
418 | } |
---|
419 | else |
---|
420 | {//primary doesn't change |
---|
421 | int index = primary.indexOfJIDStatus(jidStatus); |
---|
422 | for(Iterator j = backend.getListeners(RosterListener.class);j.hasNext();) |
---|
423 | { |
---|
424 | ((RosterListener)j.next()).jidStatusAdded(jidGroup,primary,jidStatus,index); |
---|
425 | } |
---|
426 | } |
---|
427 | */ |
---|
428 | //primary.updatePresence(secondary); |
---|
429 | |
---|
430 | /* |
---|
431 | for(Iterator j = backend.getListeners(RosterListener.class);j.hasNext();) |
---|
432 | { |
---|
433 | ((RosterListener)j.next()).jidStatussenUpdated(jidGroup,primary); |
---|
434 | } |
---|
435 | */ |
---|
436 | } |
---|
437 | private PrimaryJIDStatus addJIDStatus(String nick, JIDStatusGroup jidGroup, PrimaryJIDStatus primary, SecondaryJIDStatus jidStatus) |
---|
438 | { |
---|
439 | if (primary == null) |
---|
440 | { |
---|
441 | primary = new PrimaryJIDStatus(nick,jidStatus); |
---|
442 | jidGroup.addPrimaryJIDStatus(primary); |
---|
443 | //primary.addJIDStatus(jidStatus); |
---|
444 | int index = jidGroup.indexOfPrimaryJIDStatus(primary); |
---|
445 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
446 | {//fire add primary |
---|
447 | ((RosterListener) j.next()).primaryAdded(jidGroup, primary, index); |
---|
448 | } |
---|
449 | } |
---|
450 | else |
---|
451 | { |
---|
452 | primary.addJIDStatus(jidStatus); |
---|
453 | // int index = primary.indexOfJIDStatus(jidStatus); |
---|
454 | // for(Iterator j = backend.getListeners(RosterListener.class);j.hasNext();) |
---|
455 | // {//fire add jidstatus |
---|
456 | // ((RosterListener)j.next()).jidStatusAdded(jidGroup,primary,jidStatus,index); |
---|
457 | // |
---|
458 | // } |
---|
459 | } |
---|
460 | // primary.updatePresence(jidStatus); |
---|
461 | return primary; |
---|
462 | } |
---|
463 | |
---|
464 | private void removeJIDStatus(String group, String nick, NormalJIDStatus jidStatus) |
---|
465 | { |
---|
466 | //System.out.println("remove"); |
---|
467 | JIDStatusGroup jidGroup = jidTree.getGroup(group); |
---|
468 | PrimaryJIDStatus primary = jidGroup.searchPrimaryJIDStatus(nick); |
---|
469 | boolean oldOnline = primary.isOnline(); |
---|
470 | for (Iterator i = jidStatus.getSecondaryJIDStatussen(); i.hasNext();) |
---|
471 | { |
---|
472 | SecondaryJIDStatus secondaryJIDStatus = (SecondaryJIDStatus) i.next(); |
---|
473 | if (removeJIDStatus2(secondaryJIDStatus, jidGroup, primary)) |
---|
474 | { |
---|
475 | if(oldOnline) |
---|
476 | {//gone offline |
---|
477 | jidGroup.removeOnline(); |
---|
478 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
479 | { |
---|
480 | ((RosterListener) j.next()).groupUpdated(jidGroup, jidTree.indexOfGroup(jidGroup)); |
---|
481 | } |
---|
482 | } |
---|
483 | return; |
---|
484 | } |
---|
485 | } |
---|
486 | boolean deleted = removeJIDStatus2(jidStatus, jidGroup, primary); |
---|
487 | if(!deleted) primary.updateOnline(); |
---|
488 | if(((deleted && oldOnline) || (oldOnline && !primary.isOnline())) |
---|
489 | && -1 != jidTree.indexOfGroup(jidGroup)) |
---|
490 | {//gone offline |
---|
491 | jidGroup.removeOnline(); |
---|
492 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
493 | { |
---|
494 | ((RosterListener) j.next()).groupUpdated(jidGroup, jidTree.indexOfGroup(jidGroup)); |
---|
495 | } |
---|
496 | } |
---|
497 | //fire update |
---|
498 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
499 | { |
---|
500 | ((RosterListener) j.next()).jidStatussenUpdated(jidGroup, primary); |
---|
501 | } |
---|
502 | } |
---|
503 | |
---|
504 | private boolean removeJIDStatus2(JIDStatus jidStatus, JIDStatusGroup jidGroup, PrimaryJIDStatus primary) |
---|
505 | { |
---|
506 | //return true if primary deleted |
---|
507 | //int jidStatusIndex =0; |
---|
508 | //if(primary.hasMultiple()) jidStatusIndex = primary.indexOfJIDStatus(jidStatus); |
---|
509 | if (primary.removeJIDStatus(jidStatus)) |
---|
510 | { |
---|
511 | //if (primary.isEmpty()) |
---|
512 | { |
---|
513 | int index = jidGroup.indexOfPrimaryJIDStatus(primary); |
---|
514 | jidGroup.removePrimaryJIDStatus(primary); |
---|
515 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
516 | { |
---|
517 | //fire delete |
---|
518 | ((RosterListener) j.next()).primaryDeleted(jidGroup, primary, index); |
---|
519 | } |
---|
520 | //fire remove |
---|
521 | if (jidGroup.size() < 1) |
---|
522 | { |
---|
523 | //fire group remove |
---|
524 | int index2 = jidTree.indexOfGroup(jidGroup); |
---|
525 | jidTree.removeGroup(jidGroup); |
---|
526 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
527 | { |
---|
528 | //fire group delete |
---|
529 | ((RosterListener) j.next()).groupDeleted(jidGroup, index2); |
---|
530 | } |
---|
531 | } |
---|
532 | return true; |
---|
533 | } |
---|
534 | // else |
---|
535 | // {//fire update |
---|
536 | // for(Iterator j = backend.getListeners(RosterListener.class);j.hasNext();) |
---|
537 | // { |
---|
538 | // ((RosterListener)j.next()).jidStatussenUpdated(jidGroup,primary); |
---|
539 | // } |
---|
540 | // } |
---|
541 | } |
---|
542 | // else |
---|
543 | // {//primary doesn't change |
---|
544 | // for(Iterator j = backend.getListeners(RosterListener.class);j.hasNext();) |
---|
545 | // { |
---|
546 | // ((RosterListener)j.next()).jidStatusDeleted(jidGroup,primary,jidStatus,jidStatusIndex); |
---|
547 | // } |
---|
548 | // } |
---|
549 | return false; |
---|
550 | } |
---|
551 | |
---|
552 | //------------------------------Prescence event------------------------------------\\ |
---|
553 | |
---|
554 | public void presenceChanged(final Presence presence) |
---|
555 | { |
---|
556 | JID jid = presence.getFrom(); |
---|
557 | final NormalJIDStatus jidStatus = (NormalJIDStatus) jidStatussen.get(jid); |
---|
558 | if (jidStatus == null) |
---|
559 | { |
---|
560 | return; |
---|
561 | } |
---|
562 | if (jid.getUser() == null) |
---|
563 | { |
---|
564 | //server, server has no multiple resources |
---|
565 | jidStatus.updatePresence(presence); |
---|
566 | server.showChange(jidStatus); |
---|
567 | return; |
---|
568 | } |
---|
569 | SecondaryJIDStatus secondary = jidStatus.getSecondaryJIDStatus(jid.getResource()); |
---|
570 | boolean seconderyAdded = false; |
---|
571 | ResourceJIDStatus remove = null; |
---|
572 | if (presence.getShow() == Presence.UNAVAILABLE) |
---|
573 | { |
---|
574 | remove = jidStatus.removeResource(jid.getResource()); |
---|
575 | if (remove == null) |
---|
576 | { |
---|
577 | //no remove so no resource so update presence to unavailable |
---|
578 | secondary.updatePresence(presence); |
---|
579 | } |
---|
580 | } |
---|
581 | else |
---|
582 | { |
---|
583 | if (secondary == null) |
---|
584 | { |
---|
585 | //new resource |
---|
586 | secondary = jidStatus.addSecondaryJIDStatus(jid); |
---|
587 | seconderyAdded = true; |
---|
588 | } |
---|
589 | else if (secondary.getShow() == presence.getShow()) |
---|
590 | {//show hasn't changed |
---|
591 | if(secondary.getType().equals("msn") && secondary.getStatus()!=null |
---|
592 | && Preferences.getBoolean("jeti","showRealNick", false)) |
---|
593 | {//should status be visible? old msn transport hack, remove when new nick mechanism |
---|
594 | if(!secondary.getStatus().equals(presence.getStatus())) |
---|
595 | {//status has changed |
---|
596 | final SecondaryJIDStatus secondary2 = secondary; |
---|
597 | Runnable updateAComponent = new Runnable() { |
---|
598 | public void run() |
---|
599 | { |
---|
600 | secondary2.updatePresence(presence); |
---|
601 | for (Iterator i = jidStatus.getGroups(); i.hasNext();) |
---|
602 | {//update tree part status is in, replace by update only the changed part? |
---|
603 | JIDStatusGroup jidGroup = jidTree.getGroup((String) i.next()); |
---|
604 | PrimaryJIDStatus primary = jidGroup.searchPrimaryJIDStatus(jidStatus.getNick()); |
---|
605 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
606 | { |
---|
607 | ((RosterListener) j.next()).jidStatussenUpdated(jidGroup, primary); |
---|
608 | } |
---|
609 | } |
---|
610 | } |
---|
611 | }; |
---|
612 | SwingUtilities.invokeLater(updateAComponent); |
---|
613 | } |
---|
614 | } |
---|
615 | secondary.updatePresence(presence); |
---|
616 | return; |
---|
617 | } |
---|
618 | secondary.updatePresence(presence); |
---|
619 | //show has changed so update |
---|
620 | jidStatus.sortSecondary(); |
---|
621 | } |
---|
622 | |
---|
623 | final SecondaryJIDStatus secondary2 = secondary; |
---|
624 | final boolean seconderyAdded2 = seconderyAdded; |
---|
625 | final ResourceJIDStatus remove2=remove; |
---|
626 | |
---|
627 | Runnable updateAComponent = new Runnable() { |
---|
628 | public void run() |
---|
629 | { |
---|
630 | // change |
---|
631 | for (Iterator i = jidStatus.getGroups(); i.hasNext();) |
---|
632 | { |
---|
633 | //new jidstatus per group? |
---|
634 | JIDStatusGroup jidGroup = jidTree.getGroup((String) i.next()); |
---|
635 | PrimaryJIDStatus primary = jidGroup.searchPrimaryJIDStatus(jidStatus.getNick()); |
---|
636 | if (seconderyAdded2) primary.addJIDStatus(secondary2); |
---|
637 | if (remove2 != null) primary.removeJIDStatus(remove2); |
---|
638 | else if (secondary2 != null) primary.updatePresence(secondary2); |
---|
639 | boolean oldOnline = primary.isOnline(); |
---|
640 | primary.updateOnline(); |
---|
641 | boolean newOnline = primary.isOnline(); |
---|
642 | if(oldOnline && !newOnline) |
---|
643 | {//gone offline |
---|
644 | jidGroup.removeOnline(); |
---|
645 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
646 | { |
---|
647 | ((RosterListener) j.next()).groupUpdated(jidGroup, jidTree.indexOfGroup(jidGroup)); |
---|
648 | } |
---|
649 | } |
---|
650 | else if(!oldOnline && newOnline) |
---|
651 | {//gone online |
---|
652 | jidGroup.addOnline(); |
---|
653 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
654 | { |
---|
655 | ((RosterListener) j.next()).groupUpdated(jidGroup, jidTree.indexOfGroup(jidGroup)); |
---|
656 | } |
---|
657 | } |
---|
658 | //int index = jidGroup.indexOfPrimaryJIDStatus(primary); |
---|
659 | for (Iterator j = backend.getListeners(RosterListener.class); j.hasNext();) |
---|
660 | { |
---|
661 | ((RosterListener) j.next()).jidStatussenUpdated(jidGroup, primary); |
---|
662 | } |
---|
663 | } |
---|
664 | } |
---|
665 | }; |
---|
666 | try |
---|
667 | { |
---|
668 | SwingUtilities.invokeAndWait(updateAComponent); |
---|
669 | } catch (InterruptedException e) |
---|
670 | { |
---|
671 | e.printStackTrace(); |
---|
672 | } catch (InvocationTargetException e) |
---|
673 | { |
---|
674 | e.printStackTrace(); |
---|
675 | } |
---|
676 | } |
---|
677 | |
---|
678 | public static JIDStatus getJIDStatus(JID jid) |
---|
679 | { |
---|
680 | return (JIDStatus) jidStatussen.get(jid); |
---|
681 | } |
---|
682 | |
---|
683 | public static Iterator getJIDStatussen() |
---|
684 | { |
---|
685 | return jidStatussen.values().iterator(); |
---|
686 | } |
---|
687 | |
---|
688 | public String[] getAllGroups() |
---|
689 | { |
---|
690 | if (jidTree==null) return new String[]{ I18N.gettext("main.main.roster.Friends") }; |
---|
691 | return jidTree.getGroups(); |
---|
692 | } |
---|
693 | } |
---|
694 | |
---|
695 | /* |
---|
696 | * Overrides for emacs |
---|
697 | * Local variables: |
---|
698 | * tab-width: 4 |
---|
699 | * End: |
---|
700 | */ |
---|