JYahooPlugin


1   /*  
2       =========================================================================
3       Package aim - Implements the Yahoo! Protocol transport.
4   
5       This module is developed and maintained by PlanetaMessenger.org. 
6       Specs, New and updated versions can be found in 
7       http://www.planetamessenger.org
8       If you want contact the Team please send a email to Project Manager
9       Leidson Campos Alves Ferreira at leidson@planetamessenger.org
10  
11      Copyright (C) since 2001 by PlanetaMessenger.org
12      
13      This library is free software; you can redistribute it and/or
14      modify it under the terms of the GNU Lesser General Public
15      License as published by the Free Software Foundation; either
16      version 2.1 of the License, or (at your option) any later version.
17  
18      This library is distributed in the hope that it will be useful,
19      but WITHOUT ANY WARRANTY; without even the implied warranty of
20      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21      Lesser General Public License for more details.
22  
23      You should have received a copy of the GNU Lesser General Public
24      License along with this library; if not, write to the Free Software
25      Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26  
27      =========================================================================
28  */
29  /**
30   *
31   * $Id: JYahooPlugin.java,v 1.41 2007/02/03 07:08:04 popolony2k Exp $
32   * $Author: popolony2k $
33   * $Name:  $
34   * $Revision: 1.41 $
35   * $State: Exp $
36   *
37   */
38  
39  package org.planetamessenger.protocols.yahoo;
40  
41  import ymsg.network.*;
42  import ymsg.network.event.*;
43  import java.awt.*;
44  import java.awt.event.*;
45  import java.util.*;
46  import java.io.IOException  ;
47  import org.planetamessenger.plugin.*;
48  
49  
50  
51  public class JYahooPlugin extends JPlugin implements SessionListener, JMessengerEventListener {
52  
53    Session             session = null;
54  
55  
56    /**
57     * Initializes all class data.
58     */
59    public JYahooPlugin() {
60      
61      // To stdout log information
62      //System.getProperties().put( "ymsg.debug", "true" );
63    }
64      
65    /**
66     * Implement the onCreate event listener.
67     * Performs the plugin creation.
68     */
69    public void onCreate() {
70    
71      super.onCreate();
72      
73      JPluginCapabilities    capabilities = getPluginCapabilities();
74      
75      // Update the plugin capabilities
76      capabilities.putBool( JPluginCapabilities.CAPABILITY_OFFLINE_MESSAGE, true );
77      capabilities.putBool( JPluginCapabilities.CAPABILITY_PRIVACY_CONTROL_ENABLED, true );
78      capabilities.putBool( JPluginCapabilities.CAPABILITY_BLOCK_CONTACT, true );
79      setPluginCapabilities( capabilities );
80  
81      addMessengerEventListener( this );
82  
83      // Status management
84      addStatus( JPlugin.STATUS_ONLINE, new Long  ( StatusConstants.STATUS_AVAILABLE ) );
85      addStatus( JPlugin.STATUS_CUSTOM, new Long  ( StatusConstants.STATUS_CUSTOM ) );
86      addStatus( JPlugin.STATUS_OFFLINE, new Long  ( StatusConstants.STATUS_OFFLINE ) );
87      addStatus( JPlugin.STATUS_INVISIBLE, new Long  ( StatusConstants.STATUS_INVISIBLE ) );
88      addStatus( JPlugin.STATUS_BUSY, new Long  ( StatusConstants.STATUS_BUSY ) );
89      addStatus( JPlugin.STATUS_IDLE, new Long  ( StatusConstants.STATUS_IDLE ) );
90      addStatus( JPlugin.STATUS_DND, new Long  ( StatusConstants.STATUS_BRB ) );
91      addStatus( JPlugin.STATUS_ON_PHONE, new Long  ( StatusConstants.STATUS_ONPHONE ) );
92      addStatus( JPlugin.STATUS_ON_LUNCH, new Long  ( StatusConstants.STATUS_OUTTOLUNCH ) );
93      addStatus( JPlugin.STATUS_NOT_AT_HOME, new Long  ( StatusConstants.STATUS_NOTATHOME ) );
94      addStatus( JPlugin.STATUS_NOT_IN_OFFICE, new Long  ( StatusConstants.STATUS_NOTINOFFICE ) );
95      addStatus( JPlugin.STATUS_NOT_AT_DESK, new Long  ( StatusConstants.STATUS_NOTATDESK ) );
96      addStatus( JPlugin.STATUS_ON_VACATION, new Long  ( StatusConstants.STATUS_ONVACATION ) );
97      addStatus( JPlugin.STATUS_AWAY, new Long  ( StatusConstants.STATUS_STEPPEDOUT ) );
98    }
99    
100   /**
101    * Implement the onLogin event listener.
102    * @param nPluginStatus The initial plugin status;
103    */
104   public void onLogin( int nPluginStatus )  {
105     
106     //session = new Session( new SOCKSConnectionHandler( "autoproxy", 1080 ) );
107     //session = new Session( new HTTPConnectionHandler( "proxy", 8080 ) );
108     //session = new Session();
109     
110     session = new Session( new DirectConnectionHandler() );
111     session.addSessionListener( this );
112 
113     try {
114       session.login( getUserId(), getPassword() );
115     } catch( AccountLockedException e ) {
116       System.err.println( "JYahooPlugin.onLogin() - Your account is locked" );
117       fireOnLoginFailed();
118       fireOnRegisterUserFailed();  // Called here because this login could be a user registration (onRegisterexistingUser)
119 
120       if( e.getWebPage() != null )
121         System.err.println( "JYahooPlugin.onLogin() - Please visit: " + e.getWebPage().toString() );
122 
123       session = null;
124       return;
125     } catch( LoginRefusedException e ) {
126       System.err.println( "JYahooPlugin.onLogin() - Yahoo refused our connection.  Username/password incorrect?" );
127       fireOnLoginFailed();
128       fireOnRegisterUserFailed();  // Called here because this login could be a user registration (onRegisterexistingUser)
129       session = null;
130       return;
131     } catch( java.io.IOException   e )  {
132       System.err.println( "JYahooPlugin.onLogin() - " + e );
133       fireOnLoginFailed();
134       fireOnRegisterUserFailed();  // Called here because this login could be a user registration (onRegisterexistingUser)
135       session = null;
136       return;
137     }
138 
139     // -----Are we cooking with gas?
140     if( session.getSessionStatus() == StatusConstants.MESSAGING ) {
141       System.err.println( "JYahooPlugin.onLogin() - " + session.getConnectionHandler().toString() );
142       fireOnLoginAccepted();
143       fireOnRegisterUserSucessfull();  // Called here because this login could be a user registration (onRegisterexistingUser)
144       fireOnPluginStatusChanged( nPluginStatus );
145 
146       try  {
147         session.refreshFriends();
148       } catch( java.io.IOException   e )  {
149         System.err.println( "JYahooPlugin.onLogin() - " + e );
150       }
151     } 
152     else {
153       System.err.println( "JYahooPlugin.onLogin() - Sorry, there was a problem connecting" );
154       fireOnLoginFailed();
155       fireOnRegisterUserFailed();  // Called here because this login could be a user registration (onRegisterexistingUser)
156       session = null;
157     }
158   }
159   
160   /**
161    * Implement the onLogout event listener.
162    */
163   public void onLogout()  {
164 
165     if( isConnected() != false )  {
166       try  {
167         session.logout();
168         session.removeSessionListener( this );
169         session.reset();
170       } catch( IllegalStateException   e )  {
171         System.err.println( "JYahooPlugin.onLogin() - " + e ) ;
172       } catch( IOException   e )  {
173         System.err.println( "JYahooPlugin.onLogin() - " + e ) ;
174       }
175       
176       session = null;
177     }
178   }
179 
180   /**
181     * Implement the onAddUserToContactList event listener
182     * @param strNewUserId The User's id that will be added;
183     */
184   public void onAddUserToContactList( java.lang.String   strUserId )  {
185 
186     if( session != null )  {
187       try  {
188         session.addFriend( strUserId, "planetamessenger" );
189       } catch( IllegalStateException   e )  {
190         System.err.println( "JYahooPlugin.onAddUserToContactList() - " + e );
191       } catch( java.io.IOException   e )  {
192         System.err.println( "JYahooPlugin.onAddUserToContactList() - " + e );
193       }
194     }
195   }
196   
197   /**
198    * Implement the onRemoveUserFromContactList event
199    * listener;
200    * @param strUserId The User's id that will be removed;
201    */
202   public void onRemoveUserFromContactList( java.lang.String   strUserId )  {
203 
204     if( session != null )  {
205       try  {
206         session.removeFriend( strUserId, "planetamessenger" );
207       } catch( IllegalStateException   e )  {
208         System.err.println( "JYahooPlugin.onRemoveUserFromContactList() - " + e );
209       } catch( java.io.IOException   e )  {
210         System.err.println( "JYahooPlugin.onRemoveUserFromContactList() - " + e );
211       }
212     }
213   }
214 
215   /**
216    * Implement the onSendMessage event listener
217    * @param strToUser The user that we'll send
218    * the message;
219    * @param msg The Message that will be sent;
220    * @param nMsgType The Message type:
221    * MESSAGE_TYPE_ONLINE  - Online messages;
222    * MESSAGE_TYPE_OFFLINE - Offline messages;
223    */
224   public void onSendMessage( java.lang.String   strToUser, java.lang.String   msg, int nMsgType )  {
225 
226     if( session != null )  {
227       try  {
228         session.sendMessage( strToUser, msg );
229       } catch( IllegalStateException   e )  {
230         System.err.println( "JYahooPlugin.onSendMessage() - " + e );
231       } catch( java.io.IOException   e )  {
232         System.err.println( "JYahooPlugin.onSendMessage() - " + e );
233       }
234     }
235   }
236   
237   /**
238    * Implement the onRequestAuthorization event
239    * listener.
240    * @param strUserId The user id requesting 
241    * the authorization to add him/her to 
242    * contact list;
243    * @param strNickName The user nick name;
244    */
245   public void onRequestAuthorization( java.lang.String   strUserId, java.lang.String   strNickName )  {
246     
247   }
248 
249   /**
250    * Implement the onUserDetails event listener;
251    * @param strUserId The User id owner of
252    * this detail;
253    */
254   public void onBuddyDetails( java.lang.String   strUserId )  {
255 
256   }
257   
258   /**
259    * Implement the onAuthorizeBuddy event listener
260    * @param strUserId  The user id authorized;
261    */
262   public void onAuthorizeBuddy( java.lang.String   strUserId )  {
263     
264     onChangePrivacy( strUserId, PRIVACY_UNBLOCK_USER );
265   }
266   
267   /**
268    * Implement the onUnauthorizeBuddy event listener
269    * @param strUserId  The user id unauthorized;
270    */
271   public void onUnauthorizeBuddy( java.lang.String   strUserId )  {
272 
273     onChangePrivacy( strUserId, PRIVACY_BLOCK_USER );
274   }
275   
276   /**
277    * Implements the onPluginStatusChanged event.
278    * o nStatus - The new status for this plugin;
279    */
280   public void onPluginStatusChanged( int nStatus ) {
281     
282     if( session != null )  {
283       try  {
284         session.setStatus( ( ( Long   ) translateStatusToPlugin( nStatus ) ).longValue() );
285       } catch( IllegalArgumentException   e )  {
286         System.err.println( "JYahooPlugin.onSendMessage() - " + e );
287       } catch( java.io.IOException   e )  {
288         System.err.println( "JYahooPlugin.onSendMessage() - " + e );
289       }
290     }
291   }
292 
293   /**
294     * implement the onRegisterExistingUser
295     * event listener;
296     * @param strNickName The NickName of
297     * the user;
298     * @param strNewUserId The User's id
299     * that will be registered;
300     * @param strPasswd The User password;
301     */
302   public void onRegisterExistingUser( String   strNickName, String   strNewUserId, String   strPasswd )  {
303 
304     JUserInfo     userInfo = new JUserInfo( strNewUserId, strNickName, strPasswd, JPlugin.STATUS_ONLINE );
305     
306     setUserInfo( userInfo );
307     fireOnLogin();
308   }
309   
310   /**
311    * Implement the onRegisterNewUser event
312    * listener.
313    * @param strNickName The NickName of
314    * the user;
315    * @param strNewUserId The User's id
316    * that will be registered;
317    * @param strPasswd The User password;
318    */
319   public void onRegisterNewUser( java.lang.String   strNickName, java.lang.StringBuffer   strNewUserId, java.lang.String   strPasswd )  {
320     
321     fireOnRegisterUserFailed();  // This plugin doesnt support this feature
322   }
323 
324   /**
325    * Implement the onUnregisterUser event
326    * listener.
327    */
328   public void onUnregisterUser()  {
329    
330     if( isConnected() )  {
331       fireOnLogout();
332       fireOnUnregisterUserSuccessfull();
333     }
334   }
335   
336   /**
337    * Implement the onChangePassword event 
338    * listener
339    * @strNewPasswd The new user's password;
340    */
341   public void onChangePassword( java.lang.String   strNewPasswd )  {
342     
343     fireOnPasswordChangedSuccessfull( strNewPasswd );
344   }
345 
346   /**
347    * Implement the onChange privacy event
348    * handler.
349    * Performs a privacy control to a user
350    * for this plugin.
351    * @param strUserId The user that new privacy
352    * will be applied;
353    * @param nProvacyType The privacy type (@see JPlugin
354    * for available types);
355    */
356   public void onChangePrivacy( java.lang.String   strUserId, int nPrivacyType ) {
357     
358     try  {
359       switch( nPrivacyType )  {
360 
361         case PRIVACY_BLOCK_USER  : {
362                                      /*
363                                       * In Yahoo protocol a simple block command doesn't exist, then 
364                                       * when we need block someone throws first thing to to is remove contact
365                                       * and when user is removed from contact list, ignore the contact.
366                                       * See friendRemovedReceived() event implementation.
367                                       */
368                                      session.removeFriend( strUserId, "planetamessenger" );
369                                      System.err.println( "JYahooPlugin.onChangePrivacy() - User [" + strUserId + "] now is denied." );
370                                    }  break;
371 
372         case PRIVACY_UNBLOCK_USER : {
373                                       /*
374                                        * Read comments for PRIVACY_DENY_USER.
375                                        */
376                                       session.ignoreContact( strUserId, false );
377                                       session.addFriend( strUserId, "planetamessenger" );
378                                       System.err.println( "JYahooPlugin.onChangePrivacy() - User [" + strUserId + "] now is granted." );
379                                     }  break;
380       }
381     } catch( java.lang.IllegalStateException   ie )  {
382       System.err.println( "JYahooPlugin.onChangePrivacy() - " + ie );
383     } catch( java.io.IOException   e )  {
384       System.err.println( "JYahooPlugin.onChangePrivacy() - " + e );
385     }
386   }
387   
388   /**
389    * Implement the onPrivacyChanged event handler.
390    * This event is generated after all processing 
391    * onChangePrivacy events.
392    */
393   public void onPrivacyChanged()  {
394     
395   }
396   
397   /**
398    * Implement the onPluginPropertiesUpdated event handler.<br>
399    */
400   public void onPluginPropertiesUpdated()  {
401     
402   }
403   
404   /**
405    * Returns the plugin connection 
406    * status  .
407    */
408   public boolean isConnected()  {
409     
410     return ( ( session != null ? ( session.getSessionStatus() == StatusConstants.MESSAGING ) : false ) );
411   }
412 
413   // Yahoo YMsg9 Listener functions
414   /**
415    * Implements the messageReceived event.
416    * @param see Ymsg9 docs;
417    */
418   public void messageReceived( ymsg.network.event.SessionEvent sessionEvent ) {
419     
420     System.err.println( "JYahooPlugin.messageReceived() - Message from " + sessionEvent.getFrom() );
421         
422     fireOnReceiveMessage( sessionEvent.getFrom(), null, sessionEvent.getMessage() );
423   }
424 
425   /**
426    * Implements the offlineMessageReceived event.
427    * @param see Ymsg9 docs;
428    */
429   public void offlineMessageReceived( ymsg.network.event.SessionEvent sessionEvent ) {
430     
431     fireOnReceiveMessage( sessionEvent.getFrom(), null, sessionEvent.getMessage() );
432   }
433 
434   /**
435    * Implements the notifyReceived event.
436    * @param see Ymsg9 docs;
437    */
438   public void notifyReceived( ymsg.network.event.SessionNotifyEvent sessionNotifyEvent ) {
439 
440     System.err.println( "JYahooPlugin.notifyReceived() - Message from " + sessionNotifyEvent.getFrom() );
441   }
442 
443   /**
444    * Implements the logoffReceived event.
445    * @param see Ymsg9 docs;
446    */
447   public void logoffReceived( ymsg.network.event.SessionEvent sessionEvent ) {
448 
449     System.err.println( "JYahooPlugin.logoffReceived() - Message from " + sessionEvent.getFrom() );
450     
451     fireOnLogout();
452   }
453 
454   /**
455    * Implements the listReceived event.
456    * @param see Ymsg9 docs;
457    */
458   public void listReceived( ymsg.network.event.SessionEvent sessionEvent ) {
459 
460     System.err.println( "JYahooPlugin.listReceived()" );
461 
462     Iterator<YahooUser>    itUsers = ( session.getUsers() == null ? null : session.getUsers().values().iterator() );
463 
464     while( itUsers.hasNext() )  {
465 
466       YahooUser   user = itUsers.next();
467 
468       if( !getKernelManager().getContactListManager().isContact( this, user.getId() ) )  {
469 
470         JContactListItem    contactItem;
471 
472         getKernelManager().getContactListManager().addToContactList( this, user.getId(), user.getId() );
473         contactItem = ( JContactListItem ) getKernelManager().getContactListManager().getContact( this, user.getId() );
474         contactItem.setBlocked( user.isIgnored() );
475         contactItem.setVisible( user.isFriend() );
476         getKernelManager().getContactListManager().updatePrivacy( contactItem );
477       }
478     }
479   }
480 
481   /**
482    * Implements the friendsUpdateReceived event.
483    * @param see Ymsg9 docs;
484    */
485   public void friendsUpdateReceived( ymsg.network.event.SessionFriendEvent sessionFriendEvent ) {
486     
487     System.err.println( "JYahooPlugin.friendsUpdateReceived()" );
488 
489     YahooUser                users[] = sessionFriendEvent.getFriends();
490 
491     for( int nCount = 0; nCount < users.length; nCount++ )  {
492       
493       // The user is in contact list ? (For a unresolved bug from JYmsg9 - since aug/2005)
494       if( !getKernelManager().getContactListManager().isContact( this, users[nCount].getId() ) )  {
495         JContactListItem    contactItem;
496 
497         getKernelManager().getContactListManager().addToContactList( this, users[nCount].getId(), users[nCount].getId() );
498         contactItem = ( JContactListItem ) getKernelManager().getContactListManager().getContact( this, users[nCount].getId() );
499         contactItem.setBlocked( users[nCount].isIgnored() );
500         contactItem.setVisible( users[nCount].isFriend() );
501         getKernelManager().getContactListManager().updatePrivacy( contactItem );
502       }
503 
504       if( users[nCount].getStatus() != StatusConstants.STATUS_OFFLINE ) //  isLoggedIn() )
505         fireOnBuddyStatusChanged( users[nCount].getId(), translateStatusFromPlugin( new Long  ( users[nCount].getStatus() ) ) );
506       else
507         fireOnBuddyStatusChanged( users[nCount].getId(), JPlugin.STATUS_OFFLINE );
508     }
509   }
510 
511   /**
512    * Implements the friendRemovedReceived event.
513    * @param see Ymsg9 docs;
514    */
515   public void friendRemovedReceived( ymsg.network.event.SessionFriendEvent sessionFriendEvent ) {
516 
517     System.err.println( "JYahooPlugin.friendRemovedReceived() - " + sessionFriendEvent.getFriend().getId() );
518     
519     String                     strUserId = sessionFriendEvent.getFriend().getId();
520     JContactListItem         contact   = getKernelManager().getContactListManager().getContact( this, strUserId );
521     
522     
523     if( contact.getBlocked() )
524       try  {
525         session.ignoreContact( strUserId, true );
526       } catch( java.lang.IllegalStateException   e )  {
527         System.err.println( "JYahooPlugin.friendRemovedReceived() - " + e );
528       } catch( java.io.IOException   ioe )  {
529         System.err.println( "JYahooPlugin.friendRemovedReceived() - " + ioe );
530       }
531     
532     getKernelManager().getContactListManager().setItemStatus( this,  strUserId,  JPlugin.STATUS_OFFLINE );
533   }
534 
535   /**
536    * Implements the friendAddedReceived event.
537    * @param see Ymsg9 docs;
538    */
539   public void friendAddedReceived( ymsg.network.event.SessionFriendEvent sessionFriendEvent ) {
540     
541   }
542 
543   /**
544    * Implements the conferenceInviteReceived event.
545    * @param see Ymsg9 docs;
546    */
547   public void conferenceInviteReceived( ymsg.network.event.SessionConferenceEvent sessionConferenceEvent ) {
548     
549   }
550 
551   /**
552    * Implements the conferenceInviteDeclinedReceived event.
553    * @param see Ymsg9 docs;
554    */
555   public void conferenceInviteDeclinedReceived( ymsg.network.event.SessionConferenceEvent sessionConferenceEvent ) {
556     
557   }
558 
559   /**
560    * Implements the conferenceLogoffReceived event.
561    * @param see Ymsg9 docs;
562    */
563   public void conferenceLogoffReceived( ymsg.network.event.SessionConferenceEvent sessionConferenceEvent ) {
564     
565   }
566 
567   /**
568    * Implements the conferenceLogonReceived event.
569    * @param see Ymsg9 docs;
570    */
571   public void conferenceLogonReceived( ymsg.network.event.SessionConferenceEvent sessionConferenceEvent ) {
572     
573     
574   }
575 
576   /**
577    * Implements the conferenceMessageReceived event.
578    * @param see Ymsg9 docs;
579    */
580   public void conferenceMessageReceived( ymsg.network.event.SessionConferenceEvent sessionConferenceEvent ) {
581     
582   }
583 
584   /**
585    * Implements the contactRejectionReceived event.
586    * @param see Ymsg9 docs;
587    */
588   public void contactRejectionReceived( ymsg.network.event.SessionEvent sessionEvent ) {
589     
590   }
591 
592   /**
593    * Implements the contactRequestReceived event.
594    * @param see Ymsg9 docs;
595    */
596   public void contactRequestReceived( ymsg.network.event.SessionEvent sessionEvent ) {
597     
598   }
599 
600   /**
601    * Implements the errorPacketReceived event.
602    * @param see Ymsg9 docs;
603    */
604   public void errorPacketReceived( ymsg.network.event.SessionErrorEvent sessionErrorEvent ) {
605     
606   }
607 
608   /**
609    * Implements the fileTransferReceived event.
610    * @param see Ymsg9 docs;
611    */
612   public void fileTransferReceived( ymsg.network.event.SessionFileTransferEvent sessionFileTransferEvent ) {
613     
614   }
615 
616   /**
617    * Implements the inputExceptionThrown event.
618    * @param see Ymsg9 docs;
619    */
620   public void inputExceptionThrown( ymsg.network.event.SessionExceptionEvent sessionExceptionEvent ) {
621     
622   }
623 
624   /**
625    * Implements the newMailReceived event.
626    * @param see Ymsg9 docs;
627    */
628   public void newMailReceived( ymsg.network.event.SessionNewMailEvent sessionNewMailEvent ) {
629     
630   }
631 
632   /**
633    * Implements the buzzReceived event.
634    * @param see Ymsg9 docs;
635    */
636   public void buzzReceived( ymsg.network.event.SessionEvent sessionEvent ) {
637     
638   }
639   
640   /**
641    * Implements the chatLogoffReceived event.
642    * @param see Ymsg9 docs;
643    */
644   public void chatLogoffReceived( ymsg.network.event.SessionChatEvent sessionChatEvent ) {
645   
646   }
647 
648   /**
649    * Implements the chatLogonReceived event.
650    * @param see Ymsg9 docs;
651    */
652   public void chatLogonReceived( ymsg.network.event.SessionChatEvent sessionChatEvent ) {
653   
654   }
655 
656   /**
657    * Implements the chatMessageReceived event.
658    * @param see Ymsg9 docs;
659    */
660   public void chatMessageReceived( ymsg.network.event.SessionChatEvent sessionChatEvent ) {
661     
662   }
663 
664   /**
665    * Implements the chatConnectionClosed event.
666    * @param see Ymsg9 docs;
667    */
668   public void chatConnectionClosed( ymsg.network.event.SessionEvent sessionEvent ) {
669     
670   }
671 
672   /**
673    * Implements the chatUserUpdateReceived event.
674    * @param see Ymsg9 docs;
675    */
676   public void chatUserUpdateReceived( ymsg.network.event.SessionChatEvent sessionChatEvent ) {
677     
678   }
679   
680   /**
681    * Implements the connectionClosed event.
682    * @param see Ymsg9 docs;
683    */
684   public void connectionClosed( ymsg.network.event.SessionEvent sessionEvent ) {
685     
686   }
687   
688   
689 }
690 // JYahooPlugin class
691
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags