IRPhidget.java

Go to the documentation of this file.

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

package com.phidgets;
import java.util.Iterator;
import java.util.LinkedList;
import com.phidgets.event.*;
public final class IRPhidget extends Phidget
{
        public IRPhidget () throws PhidgetException
        {
                super (create ());
        }
        private static native long create () throws PhidgetException;

        public static final int RAWDATA_LONGSPACE = 0x7fffffff;

        public native void transmit (IRCode code, IRCodeInfo codeInfo) throws PhidgetException;
        public native void transmitRepeat () throws PhidgetException;
        public native void transmitRaw (int[]data, int offset, int count, int gap, int carrierFrequency, int dutyCycle) throws PhidgetException;
        public final void transmitRaw (int[]data) throws PhidgetException
        {
                transmitRaw (data, 0, data.length, 0, 0, 0);
        }
        public final void transmitRaw (int[]data, int gap) throws PhidgetException
        {
                transmitRaw (data, 0, data.length, gap, 0, 0);
        }
        public final void transmitRaw (int[]data, int offset, int count) throws PhidgetException
        {
                transmitRaw (data, offset, count, 0, 0, 0);
        }
        public final void transmitRaw (int[]data, int offset, int count, int gap) throws PhidgetException
        {
                transmitRaw (data, offset, count, gap, 0, 0);
        }
        public native int readRaw (int[]buffer, int offset, int count) throws PhidgetException;
        public final int readRaw (int[]buffer) throws PhidgetException
        {
                return readRaw (buffer, 0, buffer.length);
        }
        public native IRCode getLastCode () throws PhidgetException;
        public native IRLearnedCode getLastLearnedCode () throws PhidgetException;

        private final void enableDeviceSpecificEvents (boolean b)
        {
                enableCodeEvents (b && codeListeners.size () > 0);
                enableLearnEvents (b && learnListeners.size () > 0);
                enableRawDataEvents (b && rawDataListeners.size () > 0);
        }
        public final void addCodeListener (CodeListener l)
        {
                synchronized (codeListeners)
                {
                        codeListeners.add (l);
                        enableCodeEvents (true);
        }} private LinkedList codeListeners = new LinkedList ();
        private long nativeCodeHandler = 0;
        public final void removeCodeListener (CodeListener l)
        {
                synchronized (codeListeners)
                {
                        codeListeners.remove (l);
                        enableCodeEvents (codeListeners.size () > 0);
        }} private void fireCode (CodeEvent e)
        {
                synchronized (codeListeners)
                {
                        for (Iterator it = codeListeners.iterator (); it.hasNext ();)
                                ((CodeListener) it.next ()).code (e);
                }
        }
        private native void enableCodeEvents (boolean b);
        public final void addLearnListener (LearnListener l)
        {
                synchronized (learnListeners)
                {
                        learnListeners.add (l);
                        enableLearnEvents (true);
        }} private LinkedList learnListeners = new LinkedList ();
        private long nativeLearnHandler = 0;
        public final void removeLearnListener (LearnListener l)
        {
                synchronized (learnListeners)
                {
                        learnListeners.remove (l);
                        enableLearnEvents (learnListeners.size () > 0);
        }} private void fireLearn (LearnEvent e)
        {
                synchronized (learnListeners)
                {
                        for (Iterator it = learnListeners.iterator (); it.hasNext ();)
                                ((LearnListener) it.next ()).learn (e);
                }
        }
        private native void enableLearnEvents (boolean b);
        public final void addRawDataListener (RawDataListener l)
        {
                synchronized (rawDataListeners)
                {
                        rawDataListeners.add (l);
                        enableRawDataEvents (true);
        }} private LinkedList rawDataListeners = new LinkedList ();
        private long nativeRawDataHandler = 0;
        public final void removeRawDataListener (RawDataListener l)
        {
                synchronized (rawDataListeners)
                {
                        rawDataListeners.remove (l);
                        enableRawDataEvents (rawDataListeners.size () > 0);
        }} private void fireRawData (RawDataEvent e)
        {
                synchronized (rawDataListeners)
                {
                        for (Iterator it = rawDataListeners.iterator (); it.hasNext ();)
                                ((RawDataListener) it.next ()).rawData (e);
                }
        }
        private native void enableRawDataEvents (boolean b);
}