rawcall.java

jtapi for telephone

package net.sourceforge.gjtapi.raw.emulator;

/*
	Copyright (c) 2002 8x8 Inc. (www.8x8.com) 

	All rights reserved. 

	Permission is hereby granted, free of charge, to any person obtaining a 
	copy of this software and associated documentation files (the 
	"Software"), to deal in the Software without restriction, including 
	without limitation the rights to use, copy, modify, merge, publish, 
	distribute, and/or sell copies of the Software, and to permit persons 
	to whom the Software is furnished to do so, provided that the above 
	copyright notice(s) and this permission notice appear in all copies of 
	the Software and that both the above copyright notice(s) and this 
	permission notice appear in supporting documentation. 

	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT 
	OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
	HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL 
	INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING 
	FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, 
	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION 
	WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 

	Except as contained in this notice, the name of a copyright holder 
	shall not be used in advertising or otherwise to promote the sale, use 
	or other dealings in this Software without prior written authorization 
	of the copyright holder.
*/
/**
 * This models a simple call as a collection of phones.  The call has only two states: RINGING and CONNECTED.
 * Creation date: (2000-02-09 10:08:15)
 * @author: Richard Deadman
 */
import java.util.*;
import net.sourceforge.gjtapi.*;
import javax.telephony.*;
import javax.telephony.callcontrol.CallControlCall;

public class RawCall implements CallId {
	public final static int IDLE = 0;
	public final static int CONNECTED = 1;
	public final static int DEAD = 2;
	
	private java.util.HashSet legs = new HashSet();
	private PhoneManager manager = null;
	private int state;
/**
 * Create a new IDLE call that is linked back to its PhoneManager
 * Creation date: (2000-02-09 12:20:25)
 * @author: Richard
 * @param pm net.sourceforge.gjtapi.raw.emulator.PhoneManager
 */
public RawCall(PhoneManager pm) {
	super();
	this.setState(RawCall.IDLE);
	this.setManager(pm);
}
/**
 * Add a leg to the list of legs in the call
 * Creation date: (2000-02-09 10:21:24)
 * @author: Richard Deadman
 * @param leg The new call leg
 */
public void addLeg(Leg leg) {
	this.getLegs().add(leg);
	if (this.getState() == IDLE)
		this.setState(CONNECTED);
		
	RawPhone phone = leg.getPhone();
	if (phone instanceof PhoneListener)
		((PhoneListener)phone).inCall(leg);
}
/**
 * Note that a call leg has connected.  Move any legs in INPROGRESS to CONNECTED
 * Creation date: (2000-03-01 11:00:31)
 * @author: 
 */
public void connected() {
	Set legs = this.getLegs();
	Iterator it = legs.iterator();
	while(it.hasNext()) {
		Leg l = (Leg)it.next();
		if (l.getState() == Leg.INPROGRESS)
			l.connected();
	}
}
/**
 * Add a new leg to a call or change a ringing call to active.
 * Creation date: (2000-02-09 12:56:37)
 * @author: 
 * @param phone net.sourceforge.gjtapi.raw.emulator.RawPhone
 */
public void dial(RawPhone phone) throws RawStateException {
	if (phone.getState() != RawPhone.IDLE) {
		String name = phone.getAddress();
		throw new RawStateException(this, name, name,
			RawStateException.TERMINAL_CONNECTION_OBJECT,
			TerminalConnection.ACTIVE);
	}
	Leg leg = new Leg(this, phone, this.getManager().getListener(), Leg.ALERTING);
	this.setState(RawCall.CONNECTED);
}
/**
 * Add a new leg to a call or change a ringing call to active.
 * Creation date: (2000-02-09 12:56:37)
 * @author: Richard Deadman
 * @param digits The address of the remote phone
 */
public void dial(RawPhone from, String digits) throws javax.telephony.InvalidPartyException, RawStateException {
	RawPhone ph = this.getManager().getPhone(digits);
	if (ph == null) {
		// look for remote phones
		EmProvider remoteProv = EmProvider.findProvider(digits);
		if (remoteProv == null)
			throw new javax.telephony.InvalidPartyException(javax.telephony.InvalidPartyException.DESTINATION_PARTY);
		// create a remote call for this other leg
		remoteProv.getMgr().createCall(from, digits);
		ph = remoteProv.getPhone(digits);
	}
	this.dial(ph);
}
/**
 * Return a CallData snapshot holder for myself.
 * Creation date: (2000-06-23 12:46:55)
 * @author: Richard Deadman
 * @return A dat holder that holds a snapshot of myself.
 */
CallData getCallData() {
	HashSet legs = this.getLegs();
	int size = legs.size();
	ConnectionData[] conns = new ConnectionData[size];
	int i = 0;
	Iterator it = legs.iterator();
	while (it.hasNext()) {
		Leg l = (Leg)it.next();
		TCData[] tcd = new TCData[1];
		String name = l.getPhone().getAddress();
			// should probably infer the TC state...
		tcd[0] = new TCData(javax.telephony.callcontrol.CallControlTerminalConnection.ACTIVE,
						new TermData(name, true));
		conns[i] = new ConnectionData(l.getConnState(), name,
						true, tcd);
	}

	return new CallData(this, this.getCallState(), conns);
}
/**
 * Return the javax.telephony.callcontrol.CallControlCall state
 * Creation date: (2000-06-23 12:24:17)
 * @author: Richard Deadman
 * @return int
 */
private int getCallState() {
	switch (this.getState()) {
		case RawCall.IDLE: {
			return CallControlCall.IDLE;
		}
		case RawCall.CONNECTED: {
			return CallControlCall.ACTIVE;
		}
		case RawCall.DEAD: {
			return CallControlCall.INVALID;
		}
	}
	return CallControlCall.INVALID;
}
/**
 * Get the leg associated with a given phone, or null
 * Creation date: (2000-03-01 12:11:12)
 * @author: Richard Deadman
 * @return The leg attached to the phone
 * @param ph A phone object
 */
Leg getLeg(RawPhone ph) {
	if (ph instanceof TestPhone)
		ph = ((TestPhone)ph).getModel();
		
	Iterator it = this.getLegs().iterator();
	while (it.hasNext()) {
		Leg l = (Leg)it.next();
		if (l.getPhone().equals(ph)) {
			return l;
		}
	}
	return null;
}
/**
 * Return the set of Call legs
 * Creation date: (2000-02-09 10:20:37)
 * @author: Richard Deadman
 * @return HashSet
 */
private HashSet getLegs() {
	return legs;
}
/**
 * Internal accessor for the PhoneManager.
 * Creation date: (2000-02-09 12:19:56)
 * @author: Richard Deadman 
 * @return The controller of all phones.
 */
private PhoneManager getManager() {
	return manager;
}
/**
 * Insert the method's description here.
 * Creation date: (2000-02-09 12:29:03)
 * @author: 
 * @return int
 */
public int getState() {
	return state;
}
/**
 * Combine two calls together.
 * Creation date: (2000-02-28 12:20:39)
 * @author: Richard Deadman
 * @param other net.sourceforge.gjtapi.raw.emulator.RawCall
 */
public void join(RawCall other) {
	// Now tell each other Phone it is in a new call
	Iterator it = other.getLegs().iterator();
	while (it.hasNext()) {
		Leg leg = (Leg)it.next();
		leg.getPhone().swap(this, leg, this.getManager().getListener());
	}
}
/**
 * Remove and notify all remainging legs
 * Creation date: (2000-02-09 15:17:05)
 * @author: Richard Deadman
 */
public void removeAll() {
	Iterator it = this.getLegs().iterator();
	while (it.hasNext()) {
		Leg l = (Leg)it.next();
		RawPhone ph = l.getPhone();
		if (ph instanceof PhoneListener)
			((PhoneListener)ph).idle();
	}
	this.setState(DEAD);
}
/**
 * Remove a leg if it exists in this call.
 * Creation date: (2000-02-09 10:22:08)
 * @author: Richard Deadman
 * @param leg The leg to remove
 */
public void removeLeg(Leg leg) {
	// first remove the phone
	Set ls = this.getLegs();
	ls.remove(leg);	// assume equals works for Legs

	int size = ls.size();
	
		// note when no legs left
	if (size == 0) {
		// tell the manager I'm outa here -- it will notify any trailing legs
		this.setState(DEAD);
		return;		
	}
	
	// If there is only one phone left in the call, destroy the last leg and call recursively
	if (ls.size() < 2) {
		Leg last = (Leg)ls.iterator().next();
		last.drop();
	}
}
/**
 * Broadcast DTMF to all phones
 * Creation date: (2000-02-09 23:40:36)
 * @author: Richard Deadman
 * @param digits The digits to be recieved.
 */
public void sendDTMF(String digits) {
	Iterator it = this.getLegs().iterator();
	while (it.hasNext()){
		RawPhone phone = ((Leg)it.next()).getPhone();
		phone.receiveDTMF(digits);
	}
}

/**
 * Set the collection of legs
 * Creation date: (2000-02-09 10:20:37)
 * @author: 
 * @param newLegs The call leg collection
 */
private void setLegs(HashSet newLegs) {
	legs = newLegs;
}
/**
 * Insert the method's description here.
 * Creation date: (2000-02-09 12:19:56)
 * @author: 
 * @param newManager net.sourceforge.gjtapi.raw.emulator.PhoneManager
 */
private void setManager(PhoneManager newManager) {
	manager = newManager;
}
/**
 * Change the Call State.  Only Coonected and Dead are currently well handled.
 * Creation date: (2000-02-09 12:29:03)
 * @author: Richard Deadman
 * @param newState int
 */
private void setState(int newState) {
	state = newState;

	switch (newState) {
		case RawCall.CONNECTED: {
			this.getManager().getListener().callActive(this, Event.CAUSE_NORMAL);
			break;
		}
		case RawCall.DEAD: {
			this.getManager().getListener().callInvalid(this, Event.CAUSE_NORMAL);
			break;
		}
	}
}
/**
 * Describe myself
 * @return a string representation of the receiver
 */
public String toString() {
	StringBuffer sb = new StringBuffer("A Call with phones: ");
	Iterator it = this.getLegs().iterator();
	while (it.hasNext()) {
		sb.append(((Leg)it.next()).getPhone().getAddress());
		sb.append(" ");
	}
	return sb.toString();
}
}