Manager.java

Go to the documentation of this file.

/*
 * Copyright 2012 Phidgets Inc.  All rights reserved.
 */

package com.phidgets;

import com.phidgets.event.*;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Vector;

public class Manager
{
        private Vector phidgets;

        static
        {
                try
                {
                        System.loadLibrary("phidget21");
                }
                catch(UnsatisfiedLinkError ex)
                {
                        String os = System.getProperty("os.name");
                        if(os.startsWith("Linux"))
                        {
                                throw new ExceptionInInitializerError(ex.getMessage()
                                        +"\nCould not locate the Phidget C library (libphidget21.so)."
                                        +"\nMake sure it is installed, and add it's path to LD_LIBRARY_PATH.");
                        }
                        else if(os.startsWith("Windows"))
                        {
                                throw new ExceptionInInitializerError(ex.getMessage()
                                +"\nCould not locate the Phidget C library."
                                +"\nThe Windows Phidget21 MSI must be installed.");
                        }
                        else if(os.startsWith("Mac"))
                        {
                                throw new ExceptionInInitializerError(ex.getMessage()
                                +"\nCould not locate the Phidget C library."
                                +"\nThe Mac Phidget21 DMG must be installed.");
                        }
                        else
                        {
                                throw new ExceptionInInitializerError(ex.getMessage()
                                +"\nCould not locate the Phidget C library.");
                        }
                }
        }

        private long handle = 0;
        public Manager() throws PhidgetException
        {
                handle = create();
                phidgets = new Vector();
                addAttachListener(new AttachListener()
                {
                        public void attached(AttachEvent ae)
                        {
                                phidgets.add(ae.getSource());
                        }
                });
                addDetachListener(new DetachListener()
                {
                        public void detached(DetachEvent ae)
                        {
                                phidgets.remove(ae.getSource());
                        }
                });
        }
        private final native long create() throws PhidgetException;

        public final native String getServerAddress() throws PhidgetException;
        public final native String getServerID() throws PhidgetException;
        public final native int getServerPort() throws PhidgetException;
        public final native boolean isAttached() throws PhidgetException;

        public final native boolean isAttachedToServer() throws PhidgetException;

        private final native void nativeClose() throws PhidgetException;
        private final native void nativeDelete() throws PhidgetException;
        private final native void nativeOpen() throws PhidgetException;
        private final native void nativeOpenRemote(String serverID, String pass) throws PhidgetException;
        private final native void nativeOpenRemoteIP(String ipAddress, int port, String pass) throws PhidgetException;

        public final void open() throws PhidgetException {
                enableEvents(true);
                nativeOpen();
        }
        public final void open(String ipAddress, int port, String password) throws PhidgetException
        {
                enableEvents(true);
                nativeOpenRemoteIP(ipAddress, port, password);
        }
        public final void open(String ipAddress, int port) throws PhidgetException
        {
                enableEvents(true);
                nativeOpenRemoteIP(ipAddress, port, "");
        }
        public final void open(String serverID, String password) throws PhidgetException
        {
                enableEvents(true);
                nativeOpenRemote(serverID, password);
        }
        public final void open(String serverID) throws PhidgetException
        {
                enableEvents(true);
                nativeOpenRemote(serverID, "");
        }

        public final void close() throws PhidgetException {
                enableEvents(false);
                nativeClose();
        }

        private void enableEvents(boolean b)
        {
                enableManagerAttachEvents(b && attachListeners.size() > 0);
                enableManagerDetachEvents(b && detachListeners.size() > 0);
                enableServerConnectEvents(b && serverConnectListeners.size() > 0);
                enableServerDisconnectEvents(b && serverDisconnectListeners.size() > 0);
        }

        private LinkedList attachListeners = new LinkedList();
        private long nativeAttachHandler = 0;

        public final void addAttachListener(AttachListener l) {
                synchronized (attachListeners) {
                        attachListeners.add(l);
                        enableManagerAttachEvents(true);
                }
        }

        public final void removeAttachListener(AttachListener l) {
                synchronized (attachListeners) {
                        attachListeners.remove(l);
                        enableManagerAttachEvents(attachListeners.size() > 0);
                }
        }
        private void fireAttach(AttachEvent e) {
                synchronized (attachListeners) {
                        for (Iterator it = attachListeners.iterator();
                          it.hasNext(); )
                                ((AttachListener)it.next()).attached(e);
                }
        }
        private native void enableManagerAttachEvents(boolean b);

        private LinkedList detachListeners = new LinkedList();
        private long nativeDetachHandler = 0;

        public final void addDetachListener(DetachListener l) {
                synchronized (detachListeners) {
                        detachListeners.add(l);
                        enableManagerDetachEvents(true);
                }
        }

        public final void removeDetachListener(DetachListener l) {
                synchronized (detachListeners) {
                        detachListeners.remove(l);
                        enableManagerDetachEvents(detachListeners.size() > 0);
                }
        }
        private void fireDetach(DetachEvent e) {
                synchronized (detachListeners) {
                        for (Iterator it = detachListeners.iterator();
                          it.hasNext(); )
                        ((DetachListener)it.next()).detached(e);
                }
        }
        private native void enableManagerDetachEvents(boolean b);

        private LinkedList serverConnectListeners = new LinkedList();
        private long nativeServerConnectHandler = 0;

        public final void addServerConnectListener(ServerConnectListener l)
        {
                synchronized (serverConnectListeners)
                {
                        serverConnectListeners.add(l);
                        enableServerConnectEvents(true);
                }
        }

        public final void removeServerConnectListener(ServerConnectListener l)
        {
                synchronized (serverConnectListeners)
                {
                        serverConnectListeners.remove(l);
                        enableServerConnectEvents(serverConnectListeners.size() > 0);
                }
        }
        private void fireServerConnect(ServerConnectEvent e)
        {
                synchronized (serverConnectListeners)
                {
                        for (Iterator it = serverConnectListeners.iterator();
                          it.hasNext(); )
                                ((ServerConnectListener)it.next()).serverConnected(e);
                }
        }
        private native void enableServerConnectEvents(boolean b);


        private LinkedList serverDisconnectListeners = new LinkedList();
        private long nativeServerDisconnectHandler = 0;

        public final void addServerDisconnectListener(ServerDisconnectListener l)
        {
                synchronized (serverDisconnectListeners)
                {
                        serverDisconnectListeners.add(l);
                        enableServerDisconnectEvents(true);
                }
        }

        public final void removeServerDisconnectListener(ServerDisconnectListener l)
        {
                synchronized (serverDisconnectListeners)
                {
                        serverDisconnectListeners.remove(l);
                        enableServerDisconnectEvents(serverDisconnectListeners.size() > 0);
                }
        }
        private void fireServerDisconnect(ServerDisconnectEvent e)
        {
                synchronized (serverDisconnectListeners)
                {
                        for (Iterator it = serverDisconnectListeners.iterator();
                          it.hasNext(); )
                                ((ServerDisconnectListener)it.next()).serverDisconnected(e);
                }
        }
        private native void enableServerDisconnectEvents(boolean b);

        protected void finalize() throws Throwable
        {
                try
                {
                        close();
                } catch (Exception e) {
                        ;
                }
                try
                {
                        nativeDelete();
                }
                catch (Exception e)
                {
                        ;
                }
                finally{
                        handle = 0;
                        super.finalize();
                }
        }

        public String toString()
        {
                return "PhidgetManager: ";
        }

        public Vector getPhidgets()
        {
                return phidgets;
        }
}