/*
 * IncallRecord.java
 *  Copyright (c) 2004-1007  Brekeke Software, Inc. All rights reserved.
 *
 *  BREKEKE JTAPI SDK Sample Program
 *  Revised: May 17, 2007
 */

/******************************************************************************/
/*  This example application demonstrates using JTAPI to receive a call,      */
/*  record a voice and then play the recorded sound.                          */
/******************************************************************************/

import javax.telephony.*;
import javax.telephony.media.*;
import javax.telephony.callcontrol.*;
import com.brekeke.jtapi.*;


public class IncallRecord  {

	public static int recordcount=0;
	public static String workdir = "C:/JTAPI1.0/work"; /* Set your work directory of JTAPI */

	public static void main(String args[]) {
		Provider myprovider = null;

		try {
			JtapiPeer peer = JtapiPeerFactory.getJtapiPeer("com.brekeke.jtapi.BrPeer"); // MUST HAVE

			/*Put your work directory of JTAPI in the second argument*/
			myprovider = peer.getProvider("BrProvider; pdir="+workdir);
			/*Add this if you need to know Register is successful or not*/
			myprovider.addProviderListener(new CalloutPlay.MyProviderListener());
			myprovider.start();
		} catch (Exception excp) {
			System.out.println("Can't get Provider: " + excp.toString());
			System.exit(0);
		}

		/*
		 * Get the terminal we wish to monitor and add a call listener to that
		 * Terminal. This will place a call listener on all call which come to
		 * that terminal. We are assuming that Terminals are named after some
		 * primary telephone number on them.
		 */
		try {
			Terminal terminal = myprovider.getTerminal("1234");
			terminal.addCallListener(new MyCallListener());
		} catch (Exception excp) {
			System.out.println("Can't get Terminal: " + excp.toString());
			System.exit(0);
		}
	}


	static class MyProviderListener implements com.brekeke.jtapi.BrProviderListener {

		public void eventRegistFail(BrProviderEvent event) {
			System.out.println("Register failed:" + event.getSourceUrl()+" ("+event.getStatus()+")");
		}

		public void eventRegistSuccess(BrProviderEvent event) {
			System.out.println("Register successful:" + event.getSourceUrl()+" ("+event.getStatus()+")");
		}

		public void providerInService(ProviderEvent event){}    


		public void providerEventTransmissionEnded(ProviderEvent event){} /* Not supported */


		public void providerOutOfService(ProviderEvent event){} /* Not supported */


		public void providerShutdown(ProviderEvent event){}

	}


	// Listener for Call
	static class MyCallListener implements  javax.telephony.TerminalConnectionListener {

		CallControlCall mycall;
		CallControlTerminalConnection mytc;

		public void callActive(CallEvent event) {
			System.out.println("Call is now active");
		}

		public void callEventTransmissionEnded(CallEvent event) {}

		public void callInvalid(CallEvent event) {}

		public void multiCallMetaMergeEnded(MetaEvent event) {} /* Not supported */


		public void multiCallMetaMergeStarted(MetaEvent event) {} /* Not supported */


		public void multiCallMetaTransferEnded(MetaEvent event) {} /* Not supported */


		public void multiCallMetaTransferStarted(MetaEvent event) {} /* Not supported */


		public void singleCallMetaProgressEnded(MetaEvent event) {} /* Not supported */


		public void singleCallMetaProgressStarted(MetaEvent event) {} /* Not supported */


		public void singleCallMetaSnapshotEnded(MetaEvent event) {} /* Not supported */


		public void singleCallMetaSnapshotStarted(MetaEvent event) {} /* Not supported */


		public void connectionAlerting(ConnectionEvent event) {
			System.out.println("Connection Alert");
		}

		public void connectionConnected(ConnectionEvent event) {

			Connection con =  event.getConnection();
			Address addr = con.getAddress();
			String addr_name = addr.getName();

			System.out.println("Connection Connected:"+addr_name);

			if(addr_name.compareTo("1234")==0) {
				mycall = (CallControlCall) con.getCall();

				try{
					recordCall(mycall);

				}catch(Exception e){
					System.out.println("Exception when recordCall: "+e);
				}

			}

		}

		public void connectionCreated(ConnectionEvent event) {
			Connection con =  event.getConnection();
			Address addr = con.getAddress();
			String addr_name = addr.getName();

			System.out.println("Connection Created: " +addr_name);
		}

		public void connectionDisconnected(ConnectionEvent event) {
			Connection con =  event.getConnection();
			Address addr = con.getAddress();
			String addr_name = addr.getName();

			System.out.println("Connection is Disconnected: "+addr_name);
		}

		public void connectionFailed(ConnectionEvent event) {
			Connection con =  event.getConnection();
			Address addr = con.getAddress();
			String addr_name = addr.getName();

			System.out.println("Connection is failed: "+addr_name);
		}

		public void connectionInProgress(ConnectionEvent event) {
			Connection con =  event.getConnection();
			Address addr = con.getAddress();
			String addr_name = addr.getName();

			System.out.println("Connection is in progress: "+addr_name);
		}

		public void connectionUnknown(ConnectionEvent event) {
		}

		public void terminalConnectionActive(TerminalConnectionEvent event) {
			final TerminalConnection _tc = event.getTerminalConnection();
			Terminal term = _tc.getTerminal();

			System.out.println("Terminal Connection is now active: " + term.getName());
		}

		public void terminalConnectionCreated(TerminalConnectionEvent event) {
			final TerminalConnection _tc = event.getTerminalConnection();
			Terminal term = _tc.getTerminal();

			System.out.println("Terminal Connection is created: " + term.getName());
		}

		public void terminalConnectionDropped(TerminalConnectionEvent event) {
			final TerminalConnection _tc = event.getTerminalConnection();
			Terminal term = _tc.getTerminal();

			System.out.println("Terminal Connection is dropped: " + term.getName());
		}

		public void terminalConnectionPassive(TerminalConnectionEvent event) {
		}

		public void terminalConnectionRinging(TerminalConnectionEvent event) {


			try {
				final TerminalConnection _tc = event.getTerminalConnection();
				Terminal term = _tc.getTerminal();

				System.out.println("Terminal Connection is Ringing!!: " + term.getName());

				//When there is a call to 1234, answer
				if(term.getName().compareTo("1234")==0){

					Runnable r = new Runnable() {

						public void run(){
							try{
								_tc.answer();

							} catch (Exception excp){
								// handle answer exceptions
								System.out.println("Failed to answer:"+ excp);
							}
						};

					};

					Thread T = new Thread(r);
					T.start();
				}

			} catch (Exception excp) {
				System.out.println("Filed to start a thread for a new call");
			}



		}

		public void terminalConnectionUnknown(TerminalConnectionEvent event) {
		}

	}


	/*** Play and Record and play***/
	static void recordCall(Call call) throws Exception {
		new Thread(new CallRecorder(call)).start();
	}


	static class CallRecorder extends BasicMediaService implements Runnable {
		static RTC[] promptRTC = { RTC.SigDet_StopPlay };
		Call call;

		CallRecorder(Call call) {
			super((MediaProvider)call.getProvider());
			this.call = call;
		}



		public void run() {
			try {

				/* a ConfigSpec that specifies a Recorder only */
				ResourceSpec[] aRecorder = {ResourceSpec.basicRecorder};
				ConfigSpec mycs = new ConfigSpec(aRecorder, 30000, null, null,null);

				bindToCall(mycs, call);
			}
			catch(Exception ex){
				System.err.println("Exception when binding a call:"+ex);
			}

			/* Start Recording; terminate when the maximum timelimit
			 * is reached or the conection is disconnected.
			 * [you can set the timelimit in the ConfigSpec or optargs]
			 */

			PlayerEvent playev=null;
			RecorderEvent recordev=null;


			try{
				playev = play(workdir+"/sound/greeting_startrecord.ul",4, null, null);

			}catch(Exception ex){
				System.err.println("Exception when playing:"+ex);
			}

			if(playev.getError()==ErrSym.e_OK) {
				System.out.println("Play is done");
				++recordcount;
				int num = recordcount;
				try{
					recordev= record(workdir+"/sound/record"+num+".ul",null, null);
				} catch (Exception ex) {
					System.err.println("Exception when recording:"+ex);
				}

				if(recordev.getError()==ErrSym.e_OK) {
					System.out.println("Record is done");

					try{
						playev = play(workdir+"/sound/record"+num+".ul",4, null, null);

					}catch(Exception ex){
						System.err.println("Exception when playing:"+ex);
					}

					if(playev.getError()==ErrSym.e_OK) System.out.println("Play is done");
					else System.out.println("Failed to play");

				}
				else System.out.println("Failed to record");
			}
			else {
				System.out.println("Failed to play");
			}

			if (isBound()) try {
				release();
			} catch (Exception ex3) {}

			try{
				( (CallControlCall) call).drop();
			}catch(Exception ex){}
		}

	}



}