channel.java

著名的dialogic电话语音卡的java驱动程序,已经验证可用。

    protected static void register(ResourceServer resourceServer, int device) {
        if (resourceAtDev.size() <= device) {
            resourceAtDev.setSize(device + 1);
            channelAtDev.setSize(device + 1);
        }


        resourceAtDev.setElementAt(resourceServer, device);
        if ((Dialogic.debug & Dialogic.DEBUG_EVDST) != 0)
            System.out.println("Registered: " + device);
    }

    protected static void unregister(ResourceServer resourceServer, int device) {
        if (resourceAtDev.size() <= device)
            return;
        resourceAtDev.setElementAt(null, device);
    }

    /**
     * attach/dettach from resources
     * just track them to free them at clear time
     */
    public void attach(Resource aResource) {
        if (!resource.contains(aResource))
            resource.add(aResource);
    }

    public void dettach(Resource aResource) {
        if (!resource.contains(aResource)) {
            aResource.free(this);
            resource.removeElement(aResource);
        }
    }

    protected abstract EVT service(EVT event); // Do line level service of new event
    public abstract String toString();         // return a name
    public abstract void close();		       // close a channel
	public void finalize() throws Throwable 
	{
		close();
		super.finalize();
	}
    
    /**
     * Accept a call, i.e., start ringback for caller
     */
    abstract void accept();
    /**
     * @deprecated:  Old alias of answer(rings)
     */
    void accept(int rings) {
        accept();
        answer(rings);
    }
    /**
     * Answer a call now.
     */
    void answer() {
        answer(0);
    }
    /**
     * Answer a call after some ring cycles. Accepts it too if needed.
     */
    abstract void answer(int rings);
    /**
     * Reject a call with given reason
     */
    abstract void reject(int reason);
    /**
     * Start dialing - make a call
     */
    abstract void dial(Call call, String dest);
    /**
     * Request caller's ANI
     */
    abstract String ani();
    /**
     * Request call's billing info in pulses
     */
    abstract int pulses();
    
    public abstract Voice getVoice();
    public abstract Device getNetwork();

    public Integer getState() {
        return state;
    }

    public Call getCall() {
        return call;
    }

    protected void setState(Integer newState) {
        if (state != newState) {
            state = newState;
            setChanged();
            notifyObservers(state);
        }
    }

    public final static Integer FREE = new Integer(0);      // idle
    public final static Integer INCOMING = new Integer(1);  // incoming call seizure
    public final static Integer OUTGOING = new Integer(2);  // outgoing call seizure
    public final static Integer OOS = new Integer(3);       // out of service

    // Define a call handler
    public void setCallHandler(CallHandler handler) {
        this.handler = handler;
    }

    /**
     * newEvent: send a channel a user event
     */
    public void newEvent(int data) {
        EVT evt = new EVT();
        evt.type = EVT.DT_USER;
        evt.data = data;
        this.newEvent(evt);
    }
        
    protected void newEvent(EVT evt) {
        synchronized(events) {
            lastEvent = evt;
            events.add(evt);
            events.notifyAll();
        }
    }

    public EVT lastEvent() {
        return lastEvent;
    }

    public void flush() {
        EVT evt;
        synchronized(events) {
            while(events.size() > 0) {
                evt = (EVT)events.removeFirst();
                if ((Dialogic.debug & Dialogic.DEBUG_EVDST) != 0)
                    System.out.println(new java.util.Date().toString().substring(11,20) +
                            this + ": flushed " + evt);
                service(evt);
            }
        }
    }

    /** 
     * Public access to channel event stream
     */
    
    public EVT waitEvent() {
        return waitEvent(0, false);
    }

    public EVT waitEvent(long milis) {
        return waitEvent(milis, false);
    }

    /**
     * Internal (D4J functions) access to event stream
     * with precedence from public accessor. 
     * Uses boolean serviceActive to block public access
     */
     
    void beginService() {
        serviceActive = true;
    }
    
    void endService() {
        serviceActive = false;
        synchronized(events) {
            events.notifyAll();
        }
    }
    
    boolean inService() {
        return serviceActive;
    }
     
    EVT serviceWaitEvent() {
        return waitEvent(0, true);
    }

    EVT serviceWaitEvent(long milis) {
        return waitEvent(milis, true);
    }

    private EVT waitEvent(long milis, boolean service) {
        EVT evt = null;

        if (Thread.interrupted()) {
            if ((Dialogic.debug & Dialogic.DEBUG_EVDST) != 0)
                System.out.println(new java.util.Date().toString().substring(11,20) +
                    this + ": interrupted");        
            throw new ChannelException("Interrupted");
        }

        long end = 1, now = 0;
        if (milis != 0) 
            end = new Date().getTime() + milis;
        while (evt == null) {
            if (milis != 0) {
                now = new Date().getTime();
                if (now >= end) break;
            }
            synchronized(events) {
                if((events.size() == 0) || (serviceActive && !service))
                    try { 
                        if (milis != 0)
                            events.wait(end - now);
                        else
                            events.wait();
                    } catch (InterruptedException ie) {
                        if ((Dialogic.debug & Dialogic.DEBUG_EVDST) != 0)
                            System.out.println(new java.util.Date().toString().substring(11,20) +
                            this + ": interrupted");        
                        throw new ChannelException("Interrupted");
                    }
                if ((events.size() > 0) && (!serviceActive || service))
                    evt = (EVT)events.removeFirst();
            }
            if (evt != null) {
                if ((Dialogic.debug & Dialogic.DEBUG_EVDST) != 0)
                   System.out.println(new java.util.Date().toString().substring(11,20) +
                        this + ": " + evt);
                evt = service(evt);
                if ((Dialogic.debug & Dialogic.DEBUG_EVDST) != 0 && evt == null)
                    System.out.println("...serviced");
            } else {
                // Give chance to service ?
                Thread.yield();
            }
        }
        return evt;
    }

    void clear() {
        // Drop call first, to let threads know game is over... 28/1/2002
        if (call != null) {
            call.drop();
            call = null;
        }
        stopGroup(this);
        while (!resource.isEmpty()) {
            Resource aResource = (Resource)resource.firstElement();
            aResource.free(this);
            resource.removeElement(aResource);
        }
        // Just in case, free lock
        serviceActive = false;
    }
    
    public void listen(Resource res) {
        this.getNetwork().listen(this, res);
    }
}