Интерфейс системы мониторинга IP-конференций на базе Cisco Call Manager

Код приложения (часть)

MakeCall.java

import conferense.*

import conferense.center.*

import java.util.*;

import javax.telephony.*;

import javax.telephony.events.*;

public class makecall extends TraceWindow implements ProviderObserver {

Vectoractors = new Vector();

ConditionconditionInService = new Condition();

Providerprovider ;

public makecall(String[] args) {

super("makecall" + ": " + new CiscoJtapiVersion());

try {

centr.strlog("Initializing Jtapi");

int curArg = 0;

String providerName = args[curArg++];

String login = args[curArg++];

String passwd = args[curArg++];

int actionDelayMillis = Integer.parseInt(args[curArg++]);

String src = null;

String dest = null;

JtapiPeer peer = JtapiPeerFactory.getJtapiPeer(null);

if (curArg < args.length) {

String providerString = providerName + ";login=" + login + ";passwd=" + passwd;

centr.strlog("Opening " + providerString + "...\n");

provider = peer.getProvider(providerString);

provider.addObserver(this);

conditionInService.waitTrue();

centr.strlog("Constructing actors");

for (; curArg < args.length; curArg++) {

if (src == null) {

src = args[curArg];

} else {

dest = args[curArg];

ReCall ReCall = new ReCall(provider.getAddress(src), dest, this, actionDelayMillis);

actors.addElement(ReCall);

actors.addElement(

new Receiver(provider.getAddress(dest), this, actionDelayMillis, ReCall));

src = null;

dest = null;

}

}

if (src != null) {

centr.strlog("Skipping last originating address \"" + src + "\"; no destination specified");

}

}

Enumeration e = actors.elements();

while (e.hasMoreElements()) {

Actor actor = (Actor) e.nextElement();

actor.initialize();

}

Enumeration en = actors.elements();

while (en.hasMoreElements()) {

Actor actor = (Actor) en.nextElement();

actor.start();

}

} catch (Exception e) {

centr.strlog("Caught exception " + e);

}

}

public void dispose() {

centr.strlog("Stopping actors");

Enumeration e = actors.elements();

while (e.hasMoreElements()) {

Actor actor = (Actor) e.nextElement();

actor.dispose();

}

}

public static void main(String[] args) {

if (args.length < 6) {

centr.strlog("Usage: makecall <server> <login> <password> <delay> <origin> <destination> ...");

System.exit(1);

}

new makecall(args);

}

public void providerChangedEvent(ProvEv[] eventList) {

if (eventList != null) {

for (int i = 0; i < eventList.length; i++) {

if (eventList[i] instanceof ProvInServiceEv) {

conditionInService.set();

}

}

}

}

}

ReCall.java

import conferense.*

import conferense.center.*

import javax.telephony.*;

import javax.telephony.events.*;

import javax.telephony.callcontrol.*;

import javax.telephony.callcontrol.events.*;

public class ReCall extends Actor {

AddresssrcAddress ;

StringdestAddress ;

intiteration ;

StopSignalstopSignal ;

booleanready = false;

intreceiverState = Actor.ACTOR_OUT_OF_SERVICE;

boolean callInIdle = true;

public ReCall(Address srcAddress, String destAddress, Trace trace, int actionDelayMillis) {

super(trace, srcAddress, actionDelayMillis);// observe srcAddress

this.srcAddress = srcAddress;

this.destAddress = destAddress;

this.iteration = 0;

}

protected final void metaEvent(CallEv[] eventList) {

for (int i = 0; i < eventList.length; i++) {

try {

CallEv curEv = eventList[i];

if (curEv instanceof CallCtlTermConnTalkingEv) {

TerminalConnection tc = ((CallCtlTermConnTalkingEv) curEv).getTerminalConnection();

Connection conn = tc.getConnection();

if (conn.getAddress().getName().equals(destAddress)) {

delay("disconnecting");

bufCentr.strlog("Disconnecting Connection " + conn);

conn.disconnect();

}

} else if (curEv instanceof CallCtlConnDisconnectedEv) {

Connection conn = ((CallCtlConnDisconnectedEv) curEv).getConnection();

if (conn.getAddress().equals(srcAddress)) {

stopSignal.canStop();

setCallProgressState(true);

}

}

} catch (Exception e) {

centr.strlog("Caught exception " + e);

} finally {

flush();

}

}

}

protected void makecall()

throws ResourceUnavailableException, InvalidStateException,

PrivilegeViolationException, MethodNotSupportedException,

InvalidPartyException, InvalidArgumentException {

centr.strlog("Making call #" + ++iteration + " from " + srcAddress + " to " + destAddress + " " + Thread.currentThread().getName());

Call call = srcAddress.getProvider().createCall();

call.connect(srcAddress.getTerminals()[0], srcAddress, destAddress);

setCallProgressState(false);

centr.strlog("Done making call");

}

protected final void onStart() {

stopSignal = new StopSignal();

new ActionThread().start();

}

protected final void fireStateChanged() {

checkReadyState();

}

protected final void onStop() {

stopSignal.stop();

Connection[] connections = srcAddress.getConnections();

try {

if (connections != null) {

for (int i = 0; i < connections.length; i++) {

connections[i].disconnect();

}

}

} catch (Exception e) {

centr.strlog(" Caught Exception " + e);

}

}

public int getReceiverState() {

return receiverState;

}

public void setReceiverState(int state) {

if (receiverState != state) {

receiverState = state;

checkReadyState();

}

}

public synchronized void checkReadyState() {

if (receiverState == Actor.ACTOR_IN_SERVICE && state == Actor.ACTOR_IN_SERVICE) {

ready = true;

} else {

ready = false;

}

notifyAll();

}

public synchronized void setCallProgressState(boolean isCallInIdle) {

callInIdle = isCallInIdle;

notifyAll();

}

public synchronized void doAction() {

if (!ready || !callInIdle) {

try {

wait();

} catch (Exception e) {

centr.strlog(" Caught Exception from wait state" + e);

}

} else {

if (actionDelayMillis != 0) {

centr.strlog("Pausing " + actionDelayMillis + " milliseconds before making call ");

flush();

try {

wait(actionDelayMillis);

} catch (Exception ex) {

}

}

if (ready && callInIdle) {

try {

makecall();

} catch (Exception e) {

centr.strlog(" Caught Exception in MakeCall " + e + " Thread =" + Thread.currentThread().getName());

}

}

}

}

class ActionThread extends Thread {

ActionThread() {

super("ActionThread");

}

public void run() {

while (true) {

doAction();

}

}

}

}

Receiver.java

import conferense.*

import conferense.center.*

import javax.telephony.*;

import javax.telephony.events.*;

import javax.telephony.callcontrol.*;

import javax.telephony.callcontrol.events.*;

public class Receiver extends Actor {

Addressaddress ;

StopSignalstopSignal ;

ReCallReCall ;

public Receiver(Address address, Trace trace, int actionDelayMillis, ReCall ReCall) {

super(trace, address, actionDelayMillis);

this.address = address;

this.ReCall = ReCall;

}

protected final void metaEvent(CallEv[] eventList) {

for (int i = 0; i < eventList.length; i++) {

TerminalConnection tc = null;

try {

CallEv curEv = eventList[i];

if (curEv instanceof CallCtlTermConnRingingEv) {

tc = ((CallCtlTermConnRingingEv) curEv).getTerminalConnection();

delay("answering");

bufCentr.strlog("Answering TerminalConnection " + tc);

tc.answer();

stopSignal.canStop();

}

} catch (Exception e) {

bufCentr.strlog("Caught exception " + e);

bufCentr.strlog("tc = " + tc);

} finally {

flush();

}

}

}

protected final void onStart() {

stopSignal = new StopSignal();

}

protected final void onStop() {

stopSignal.stop();

Connection[] connections = address.getConnections();

try {

if (connections != null) {

for (int i = 0; i < connections.length; i++) {

connections[i].disconnect();

}

}

} catch (Exception e) {

centr.strlog(" Caught Exception " + e);

}

}

protected final void fireStateChanged() {

ReCall.setReceiverState(state);

}

}

StopSignal.java

import conferense.*

import conferense.center.*

import javax.telephony.*;

import javax.telephony.events.*;

import javax.telephony.callcontrol.*;

import javax.telephony.callcontrol.events.*;

class StopSignal {

boolean stopping = false;

boolean stopped = false;

synchronized boolean isStopped() {

return stopped;

}

synchronized boolean isStopping() {

return stopping;

}

synchronized void stop() {

if (!stopped) {

stopping = true;

try {

wait();

} catch (InterruptedException e) {

}

}

}

synchronized void canStop() {

if (stopping = true) {

stopping = false;

stopped = true;

notify();

}