source: branches/2.2/jabberit_messenger/java_source/src/nu/fw/jeti/jabber/Backend.java @ 3102

/* 
 *      Jeti, a Java Jabber client, Copyright (C) 2003 E.S. de Boer  
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *      For questions, comments etc, 
 *      use the website at http://jeti.jabberstudio.org
 *  or mail/im me at jeti@jabber.org
 */
package nu.fw.jeti.jabber;

import java.awt.Container;
import java.awt.Frame;
import java.awt.Window;
import java.util.*;

import javax.swing.JFrame;

import nu.fw.jeti.backend.*;
import nu.fw.jeti.backend.roster.Roster;
import nu.fw.jeti.backend.roster.Server;
import nu.fw.jeti.events.*;
import nu.fw.jeti.jabber.elements.IQXCaps;
import nu.fw.jeti.jabber.elements.InfoQuery;
import nu.fw.jeti.jabber.elements.Message;
import nu.fw.jeti.jabber.elements.Packet;
import nu.fw.jeti.jabber.elements.StreamError;
import nu.fw.jeti.jabber.handlers.ExtensionHandler;
import nu.fw.jeti.ui.Jeti;

/**
 * @author E.S. de Boer
  */

public class Backend
{
    private Map eventListeners;
        private Map presenceListeners;
        private Map messageListeners;   
        private int identifier;
        private Connect connect;
        private Roster roster;
        private Server server;
        private Jeti main;
        private JFrame mainFrame;
        private Container mainWindow;
        private Start start;
        private IQTimerQueue iqTimerQueue;
        private Handlers handlers;
        private CapabilitiesCache capabilitiesCache;
        
        
    public Backend(Start start)
    {
                eventListeners = new HashMap(10);
                iqTimerQueue = new IQTimerQueue();
                handlers = new Handlers();
                connect = new Connect(this,iqTimerQueue,handlers);
                server =new Server(this);
                roster = new Roster(this,server);
                capabilitiesCache = new CapabilitiesCache(this);
                this.start = start;
    }
   
        public void setMain(Jeti main,Window window, JFrame frame)
        {
                this.main = main;
                this.mainWindow = window;
                this.mainFrame = frame;
        }

        public Container getMainWindow()
        {//TODO bit of a hack, think of something nicer
                if( mainWindow == null )
                {
                        mainWindow=main.getTopLevelAncestor();
                }
                return mainWindow;
        }
        
        public JFrame getMainFrame()
        {
                return mainFrame;
        }
        
        public Jeti getMain(){return main;}
/*
        public void setBackend(JabberBackend backend)
        {
            this.backend = backend;
        }
*/
        public void login(LoginInfo loginInfo)
        {
                connect.login(loginInfo);
        }
        
        public void autoLogin(LoginInfo loginInfo,int tries)
        {
                connect.autoLogin(loginInfo,tries);
        }
        
        public void abortLogin()
        {
                connect.abort();
        }

        public JID getMyJID()
        {
                return Connect.getMyJID();
        }
        
        /**
         * Checks if the password matches the password used to login on this account
         * @param password the password to check
         * @return true if the password matches the password of this account
         */
        public boolean isPasswordValid(String password)
        {
                return connect.isPasswordValid(password);
        }

        public synchronized String getIdentifier()
        {
                return "JETI_" + identifier++;
        }

        public String createThread()
        {
                return  Integer.toHexString("JETI".hashCode()) + Long.toHexString(System.currentTimeMillis());
        }

        public String getAccountInfo()
        {
                return connect.getAccountInfo();
        }
        
        public Map getAvailableTransports()
        {
                return server.getAvailableTransports();
        }

        public void changeStatus(int show,String status)
        {
                connect.changeStatus(show, status);
        }

        public void rosterLoaded()
        {
                connect.connected();
        }

        public void disconnect()
        {
                connect.disconnect();
        }
        
        public boolean isLoggedIn()
        {
                return connect.isLoggedIn();
        }

        public void streamError(StreamError error)
        {
                connect.streamError(error);
        }

        public void exit()
        {
                if(!Start.applet)
                {
                        System.out.println("This window will close in one minute");
                        Timer t = new Timer(true);
                        t.schedule(new TimerTask()
                        {
                                public void run()
                                {
                                        System.exit(0);
                                }
                        },10000);
                }
                                
                //end connection
                connect.exit();
                
                Frame[] frames = Frame.getFrames();
                for(int i =0;i<frames.length;i++)
                {//remove all opened jeti frames
                        String name = frames[i].getClass().getName();
                        System.out.println(name);
                        if(name.startsWith("nu.fw.jeti"))frames[i].dispose();
                        //frames[i].dispose();
                        if(frames[i].isDisplayable())System.out.println(name);
                }
                
                capabilitiesCache.save();
                //unload plugins
                start.exit();
                //remove references'
//              start=null;
//              connect=null;
//              roster=null;
//              server=null;
//              main=null;
//              mainFrame=null;
//              mainWindow =null;
                synchronized (this)
                {
                        eventListeners.clear();
                        if(presenceListeners!=null)presenceListeners.clear();
                        if(messageListeners!=null)messageListeners.clear();
                }
        }

        /**
         *      send packets
         *      please send messages that need to be logged with sendMessage
         *  @param packet
         */
        public void send(Packet packet)
        {
                connect.send(packet);
        }
        
        /**
         * Sends a infoquery and gives the result to listener
         * @param query the infoquery to send
         * @param listener the IQResultListener wich listens for the result
         * @param timeout not yet implemented 
         */
        public void send(InfoQuery query, IQResultListener listener,int timeout)
        {
                iqTimerQueue.add(query,listener,timeout);
                send(query);
        }

        /**
         * needed to log own send messages
         * @param message
         */
        public void sendMessage(Message message)
        {
                //if(isr
                for(Iterator j = getListeners(OwnMessageListener.class);j.hasNext();)
                {
                        ((OwnMessageListener)j.next()).sendMessage(message);
                }
                connect.send(message);
        }

//      public void browse(JID jid, BrowseListener listener)
//      {
//              connect.browse(jid,listener);
//      }
        
        public void getItems(JID jid, DiscoveryListener listener, boolean useCache)
        {
                connect.getItems(jid,listener,useCache);
        }
        
        public void getItems(JID jid, DiscoveryListener listener)
        {
                connect.getItems(jid,listener);
        }
        
        public void getInfo(JID jid, DiscoveryListener listener)
        {
                connect.getInfo(jid,listener);
        }
        
        public void getItems(JID jid,String node, DiscoveryListener listener)
        {
                connect.getItems(jid,node,listener);
        }
        
        public void getInfo(JID jid,String node, DiscoveryListener listener)
        {
                connect.getInfo(jid,node,listener);
        }
        
        /**
         * gets the current Jabber status of the user
         * @return the current status
         */
        public int getStatus()
        {
                return connect.getStatus();
        }
        
        
//      //muc hack
//      public void browseNotCached(JID jid, BrowseListener listener)
//      {
//              connect.browseNotCached(jid,listener);
//      }

        public static JIDStatus getJIDStatus(JID jid)
        {
                return Roster.getJIDStatus(jid);
        }

        public String[] getAllGroups()
        {
                return roster.getAllGroups();
        }

        /**
         * makes a new account
         * (the current connection will be logged off)
         * @param name Username (may be null)
         * @param password User password (may be null)
         */
        public void newAccount(String server,int port,String name,String password)
        {
                disconnect();
                new NewAccount(server,port,handlers,name,password);
        }
        
        public void setCapability(JID jid, IQXCaps caps){
                capabilitiesCache.setCapability(jid, caps);
        }
        
        /**
         * Has JID jid capability capability
         * @param jid
         * @param capability
         * @return true if the jid has the capability
         */
        public boolean hasCapability(JID jid, String capability){
                return capabilitiesCache.hasCapability(jid, capability);
        }
        
        public void addCapability(String capability,String feature){
                connect.addCapability(capability, feature);
        }
        
        public void removeCapability(String capability,String feature){
                connect.removeCapability(capability, feature);
        }
        
        
        
        public void addExtensionHandler(String namespace,ExtensionHandler handler)
        {
                handlers.addExtensionHandler(namespace,handler);
        }
        
        public void removeExtensionHandler(String namespace)
        {
                handlers.removeExtensionHandler(namespace);
        }
        
        /**
         * Add a listener for a specific presence
         * @param jid The JID of which the presence is to be monitored (resource is not considered) 
         * @param listener The class that is interested in presence events
         */
        public synchronized void addPresenceListener(JID jid, PresenceListener listener)
        {
                 if(presenceListeners == null)presenceListeners = new HashMap(); 
                 presenceListeners.put(jid,listener); 
        }
        
        /**
         * removes a presencelistener
         * @param jid The JID of which presence is monitored
         */
        public synchronized void removePresenceListener(JID jid)
        {
                if(presenceListeners==null)return;
                presenceListeners.remove(jid);
                if (presenceListeners.isEmpty()) presenceListeners = null;
        }
        
        /**
         * Gets the presenceListener which is monitoring this JID 
         * @param jid The JID of which the presenceListener is requested
         * @return PresenceListener
         */
        public synchronized PresenceListener getPresenceListener(JID jid)
        {
                if(presenceListeners == null) return null;
                return (PresenceListener)presenceListeners.get(jid);
        }
        
        /**
         * Add a listener for messages to this JID
         * @param jid The JID of which the message is to be monitored (resource is not considered) 
         * @param listener The class that is interested in message events
         */
        public synchronized void addMessageListener(JID jid, MessageListener listener)
        {
                 if(messageListeners == null)messageListeners = new HashMap(); 
                 messageListeners.put(jid,listener); 
        }
        
        /**
         * removes a messagelistener
         * @param jid The JID of which messages are monitored
         */
        public synchronized void removeMessageListener(JID jid)
        {
                if(messageListeners==null)return;
                messageListeners.remove(jid);
                if (messageListeners.isEmpty()) messageListeners = null;
        }
        
        /**
         * Gets the MessageListener which is monitoring this JID 
         * @param jid The JID of which the messageListener is requested
         * @return MessageListener
         */
        public synchronized MessageListener getMessageListener(JID jid)
        {
                if(messageListeners == null) return null;
                return (MessageListener)messageListeners.get(jid);
        }
        
        public synchronized void addListener(Class type, JETIListener listener)
        {//class meegeven?
                LinkedList list = (LinkedList) eventListeners.get(type.getName());
                if(list == null)
                {
                        list = new LinkedList();
                    eventListeners.put(type.getName(),list);
                }
                list.add(listener);
        }

        public synchronized void removeListener(Class type, JETIListener listener)
        {
                LinkedList list = (LinkedList) eventListeners.get(type.getName());
                if(list == null) return;
                list.remove(listener);
                if(list.isEmpty()) eventListeners.remove(type.getName());//good idea?
        }

        public synchronized Iterator getListeners(final Class type)
        {
                LinkedList listeners = (LinkedList)eventListeners.get(type.getName());
                if(listeners == null)
                {//no listeners so return a empty iterator, if happens use isRegisteredListener(class type)
                        return new Iterator()
                        {//empty iterator
                                public Object next()
                                {
                                        throw new NoSuchElementException();
                                }
                                public boolean hasNext()
                                {
                                        //System.out.println(type + " listener not registerd");
                                        //throw new RuntimeException();
                                        return false;
                                }
                                public void remove()
                                {
                                        throw new UnsupportedOperationException();
                                }
                        };
                }
                return new LinkedList(listeners).iterator();//no concurrentmodexcep
        }
}

/*
 * Overrides for emacs
 * Local variables:
 * tab-width: 4
 * End:
 */