redial-ruby-agi 2.0.1

data/lib/ruby-agi/asterisk_variable.rb

@@ -0,0 +1,242 @@
+#
+#  File: asterisk_variables.rb
+# 
+#  ruby-agi: Ruby Language API for Asterisk
+#
+#  Copyright (C) <2005>  Mohammad Khan <info@beeplove.com>
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+# == Overview
+#
+
+# Followings are the list of AGI variables
+#    -- ruby-agi >> agi_request
+#    -- ruby-agi >> agi_channel
+#    -- ruby-agi >> agi_language
+#    -- ruby-agi >> agi_type
+#    -- ruby-agi >> agi_uniqueid
+#    -- ruby-agi >> agi_callerid
+#    -- ruby-agi >> agi_dnid
+#    -- ruby-agi >> agi_rdnis
+#    -- ruby-agi >> agi_context
+#    -- ruby-agi >> agi_extension
+#    -- ruby-agi >> agi_priority
+#    -- ruby-agi >> agi_enhanced
+#    -- ruby-agi >> agi_accountcode
+
+
+require 'ruby-agi/agi.rb'
+require 'ruby-agi/error.rb'
+
+class AGI
+end
+
+class AsteriskVariable < AGI
+
+	def initialize
+		env
+	end
+
+	protected
+	def env
+		if @asterisk_variable.nil?
+			@asterisk_variable = Hash.new
+			semaphore do 
+				$stdin.each_line do | line |
+					line.strip!
+					break if line.nil? or line.size.zero? or line == "\n"
+					key, value = line.split(':')
+					value.strip! if not value.nil?
+					if ((not key.nil?) and (not key.to_s.size.zero?))
+						@asterisk_variable[key.to_s] = value
+					end
+				end
+			end
+		end
+
+		return @asterisk_variable
+	end
+
+	protected
+	def read_env(name)
+		if debug?
+			semaphore do
+				$stderr.puts "    -- ruby-agi-trunk << Read asterisk variable '#{name}'"
+				$stderr.puts "    -- ruby-agi-trunk >> Asterisk variable #{name} = #{env[name].to_s}"
+			end	
+		end
+
+		return env[name]
+	end
+
+	public
+	def request
+		return read_env('agi_request')
+	end
+
+	public
+	def channel
+		return read_env('agi_channel')
+	end
+
+	public
+	def language
+		return read_env('agi_language')
+	end
+
+	public
+	def type
+		return read_env('agi_type')
+	end
+
+	public
+	def uniqueid
+		return read_env('agi_uniqueid')
+	end
+
+	public
+	def callerid
+		if @callerid.nil?
+			init_caller_variable
+		end
+
+		return @callerid
+	end
+
+	public
+	def dnid
+		return read_env('agi_dnid')	
+	end
+
+	public
+	def rdnid
+		return read_env('agi_rdnid')	
+	end
+
+	public
+	def context
+		return read_env('agi_context')	
+	end
+
+	public
+	def extension
+		return read_env('agi_extension')	
+	end
+
+	public
+	def priority
+		return read_env('agi_priority')	
+	end
+
+	public
+	def enhanced
+		return read_env('agi_enhanced')	
+	end
+
+	public
+	def accountcode 
+		return read_env('agi_accountcode')
+	end
+
+	####################################################################
+	####  additional methods generated from existing basic methods  ####
+	####################################################################
+
+	public
+	def calleridname
+		if @calleridname.nil?
+			init_caller_variable
+		end
+		
+		return @calleridname
+	end
+
+	public
+	def calleridnumber
+		if @calleridnumber.nil?
+			init_caller_variable
+		end
+
+		return @calleridnumber
+	end
+
+	# following methods are not confirm that they are AGI variables
+	public
+	def callingpres
+		return read_env('agi_callingpres')	
+	end
+
+	public
+	def callingani2
+		return read_env('agi_callingani2')	
+	end
+
+	public
+	def callington
+		return read_env('agi_callington')	
+	end
+
+	public
+	def callingtns
+		return read_env('agi_callingtns')	
+	end
+
+	# asterisk-1.0.9  : agi_callerid (default value is 'unknown')
+	# asterisk-1.0.10 : agi_callerid (default value is 'unknown')
+	# asterisk-1.0.10 : agi_callerid, agi_calleridname (default value for both is 'unknown')
+	protected
+	def init_caller_variable
+		@callerid = read_env('agi_callerid').to_s.strip
+		if @callerid == "unknown"
+			@callerid		= ""
+			@calleridname	= ""
+			@calleridnumber	= ""
+		elsif Regexp.new(/^\d+\d$/).match(@callerid)
+			@calleridname	= read_env('agi_calleridname')
+			if @calleridname.nil?
+				@calleridname = "UNKNOWN"
+			end
+			@calleridnumber	= @callerid
+		else
+			@calleridname	= read_env('agi_calleridname')
+			if @calleridname.nil?					# for asterisk that don't have agi variable 'agi_calleridname'
+				name		= Regexp.new(/\".+\"/).match(@callerid)
+				number		= Regexp.new(/\<\d+\>/).match(@callerid)
+
+				if name.nil?
+					@calleridname = ""
+				else
+					name = name.to_s
+					name.gsub!(/\"/, '')
+					@calleridname = name.to_s.strip
+				end
+
+				if number.nil?
+					@calleridnumber = ""
+				else
+					number = number.to_s
+					number.sub!(/\</, '')
+					number.sub!(/\>/, '')
+					@calleridnumber = number.to_s.strip
+				end
+			else									# for asterisk that have agi variable 'agi_calleridname'
+				@calleridnumber	= @callerid
+				@callerid		= "\"#{@calleridname}\" <#{@calleridnumber}>"
+			end
+		end
+	end
+end

data/lib/ruby-agi/command.rb

@@ -0,0 +1,911 @@
+#
+#  File: command.rb
+#
+#  ruby-agi: Ruby Language API for Asterisk
+#
+#  Copyright (C) <2005>  Mohammad Khan <info@beeplove.com>
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+# this would be the most used class
+
+# most common arguements
+# timeout: nil, zero, neative =forever, 
+# escape_digit, by default #, if nil passed as argument there will not have any escape
+# escape_digits, by default #, if nil passed as argument there will not have any escape
+# channel, current channel otherwise mentioned
+# max_digit, maximum number of digits would be accepted from user, always 255 otherwise mentioned
+# filename, name of file to be streamed, recoreds ..
+# beep, always yes, otherwise passed false or nil as argument
+# format, always gsm otherwise mentioned
+# secs, all methods need time as an argument are passed as seconds
+
+require 'sync'
+
+require 'ruby-agi/agi.rb'
+require 'ruby-agi/error.rb'
+require 'ruby-agi/return_status.rb'
+
+class AGI
+end
+
+class ReturnStatus
+end
+
+class Answer < ReturnStatus
+end
+
+
+class Command < AGI
+	def initialize
+	end
+	
+	# 
+	# Answers channel if not already in answer state. 
+	#
+	# <b>Parameters</b>
+	# - none
+	#
+	# <b>Returns</b> 
+	# - ReturnStatus object
+	#
+	# failure: 200 result=-1 
+	# success: 200 result=0 
+	# Command Reference: ANSWER
+	#
+	public
+	def answer
+		cmd = "ANSWER"
+		rs = exec_command(cmd, Answer)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Cause the channel to automatically hangup at <time> seconds in the future. 
+	# Of course it can be hungup before then as well. 
+	# Setting to 0 will cause the autohangup feature to be disabled on this channel. 
+	#
+	# <b>Parameters</b>
+	# - time : number of seconds, after this time period channel will be automatically hung up
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# 200 result=0 
+	# Command Reference: SET AUTOHANGUP <time> 
+	#
+	public
+	def set_auto_hangup(secs=0)
+		cmd = "SET AUTOHANGUP #{secs.to_s}"
+		rs = exec_command(cmd, SetAutoHangup)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#	
+	# Returns the status of the specified channel. 
+	# If no channel name is given the returns the status of the current channel. 
+	# 
+	# <b>Parameters</b>
+	# - channel	: name of the channel.
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# failure: 200 result=-1 
+	# success: 200 result=<status> 
+	# <status> values: 
+	# 0 Channel is down and available 
+	# 1 Channel is down, but reserved 
+	# 2 Channel is off hook 
+	# 3 Digits (or equivalent) have been dialed 
+	# 4 Line is ringing 
+	# 5 Remote end is ringing 
+	# 6 Line is up 
+	# 7 Line is busy 
+	# Command Reference: CHANNEL STATUS [<channelname>] 
+	#
+	public
+	def channel_status(channel=nil)
+		if channel.nil?
+			channel = ""
+		end
+
+		cmd = "CHANNEL STATUS #{channel.to_s}"
+		rs = exec_command(cmd, ChannelStatus)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Executes <application> with given <options>. 
+	# Applications are the functions you use to create a dial plan in extensions.conf. 
+	#
+	# <b>Parameters</b>
+	# - application	: Asterisk command of the application 
+	# - options		: options to be passed with the asterisk application
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# failure: 200 result=-2 
+	# success: 200 result=<ret> 
+	# Command Reference: EXEC <application> <options> 
+	#
+	public
+	def exec(application, options=nil)
+		if options.nil?
+			options = ""
+		end
+		cmd = "EXEC #{application.to_s} #{options.to_s}"
+		rs = exec_command(cmd, Exec)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	
+	#
+	# method to get digit(s)
+	# pressing '#' will always terminate the input process
+	#
+	# <b>Parameters</b>
+	# - filename : audio to be played before get as input
+	# - timeout  : maximum allowed time in second(s) to receive each digit
+	#              wait for ever if timeout is nil or negative or zero
+	# - max_digit: maximum number of digits to get as input
+	#              wait for unlimited number of digits if max_digit is nil or negative or zero
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# failure: 200 result=-1
+	# timeout: 200 result=<digits> (timeout)
+	# success: 200 result=<digits>
+	# <digits> is the digits pressed. 
+	# Command Reference: GET DATA <file to be streamed> [timeout] [max digits]
+	#
+	public
+	def wait_for_digits(filename, timeout=nil, max_digit=nil)
+		
+		timeout = sanitize_timeout(timeout)
+		max_digit = sanitize_max_digit(max_digit)
+
+		cmd = "GET DATA #{filename.to_s} #{timeout.to_s} #{max_digit.to_s}"
+
+		rs = exec_command(cmd, WaitForDigits)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# method to read a variable
+	#
+	# <b>Parameters</b>
+	# - name	: name of the variable to read
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# Does not work with global variables. Does not work with some variables that are generated by modules.
+	# failure or not set: 200 result=0
+	# success: 200 result=1 <value>
+	# Command Reference: GET VARIABLE <variablename>
+	# 
+	public
+	def get_variable(name)
+		cmd = "GET VARIABLE #{name.to_s}"
+		rs = exec_command(cmd, GetVariable)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# method to hang up the specified channel.
+	# If no channel name is given, hangs up the current channel.
+	#
+	# <b>Parameters</b>
+	# - channel	: name of the channel to hang up
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# failure: 200 result=-1
+	# success: 200 result=1
+	# Command Reference: HANGUP [<channelname>] 
+	#
+	public
+	def hangup(channel=nil)
+		if channel.nil?
+			channel = ""
+		end
+
+		cmd = "HANGUP #{channel.to_s}"
+		rs = exec_command(cmd, Hangup)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#	
+	# method that Does nothing !!
+	#
+	# <b>Parameters</b>
+	# - msg : message to pass this method
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	# success: 200 result=0 
+	# Command Reference: Usage: NOOP 
+	#
+	public
+	def noop(msg)
+		cmd = "NOOP #{msg.to_s}"
+		rs = exec_command(cmd, Noop)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Receives a character of text on a channel, and discards any further characters after the first one waiting.
+	# Most channels do not support the reception of text. See Asterisk Text for details.
+	#
+	# <b>Parameters</b>
+	# - timeout : maximum time to wait for input in seconds
+	#             negative or zero is not acceptable
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# failure or hangup: 200 result=-1 (hangup)
+	# timeout: 200 result=<char> (timeout)
+	# success: 200 result=<char>
+	# <char> is the character received, or 0 if the channel does not support text reception.
+	# Command Reference: RECEIVE CHAR <timeout>
+	#
+	public
+	def receive_char(timeout)
+		timeout = sanitize_timeout(timeout)
+		raise(ArgumentError, "timeout need to be positive") if (timeout < 1)
+
+		cmd = "RECEIVE CHAR #{timeout.to_s}"
+		rs = exec_command(cmd, ReceiveChar)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+	
+    # 
+	# Receives a string text on a channel.
+	# Most channels do not support the reception of text.
+	#
+	# <b>Parameters</b>
+	# - timeout	: time to wait for input in seconds
+	#             negative or zero is not acceptable
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# failure, hangup, or timeout: 200 result=-1
+	# success: 200 result=<text>
+	# <text> is the text received on the channel.
+	# Command Reference: RECEIVE TEXT <timeout>
+	#
+	public
+	def receive_text(timeout)
+		timeout = sanitize_timeout(timeout)
+		raise(ArgumentError, "timeout need to be positive") if (timeout < 1)
+
+		cmd = "RECEIVE TEXT #{timeout.to_s}"
+		rs = exec_command(cmd, ReceiveText)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Record to a file until <escape digits> are received as dtmf.
+	#
+	# <b>Parameters</b>
+	# - filename		: location of the file where the audio file will be saved
+	# - format			: specify what kind of file will be recorded.
+	# - escape_digits	: digit(s) to be pressed to complete recording
+	# - timeout			: maximum record time in seconds
+	#                     nil, negative or 0 for no timeout.
+	# - offset			: [offset samples] is optional,
+	#                     and if provided will seek to the offset without exceeding the end of the file.
+	# - silence		 	: number of seconds of silence allowed before the function returns
+	#                     despite the lack of dtmf digits or reaching timeout.
+	#                     Silence value must be preceeded by "s=" and is optional.
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# failure to write: 200 result=-1 (writefile)
+	# failure on waitfor: 200 result=-1 (waitfor) endpos=<offset>
+	# hangup: 200 result=0 (hangup) endpos=<offset>
+	# interrrupted: 200 result=<digit> (dtmf) endpos=<offset>
+	# timeout: 200 result=0 (timeout) endpos=<offset>
+	# random error: 200 result=<error> (randomerror) endpos=<offset>
+	# <offset> is the end offset in the file being recorded.
+	# <digit> is the ascii code for the digit pressed.
+	# <error> ?????
+	#
+	# Command Reference: RECORD FILE <filename> <format> <escape digits> <timeout> [offset samples] [BEEP] [s=<silence>]
+	#
+	public
+	def record_file(filename, format='gsm', escape_digits='#', timeout=nil, beep=true)
+
+		format = sanitize_file_format(format)
+		escape_digits = sanitize_escape_digits(escape_digits)
+		timeout = sanitize_timeout(timeout)
+		
+		
+		if ((escape_digits == "X") and (timeout == -1))
+			raise(ArgumentError, "need at least one valid escape digit or timeout need te positive")
+		end
+		
+		cmd = "RECORD FILE #{filename} #{format} #{escape_digits} #{timeout}"
+		cmd = "#{cmd} beep" if beep == true
+		rs = exec_command(cmd, RecordFile)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+
+	#
+	# Say a given digit string, returning early if any of the given DTMF digits are received on the channel.
+	#
+	# <b>Parameters</b>
+	# - number			: number to announce
+	# - escape_digit	: if digit pressed during playback, will return from announce
+	#
+	# <b>Returns</b>
+	# - ReturnStatus (object)
+	#
+	# failure: 200 result=-1
+	# success: 200 result=0
+	# digit pressed: 200 result=<digit>
+	# <digit> is the ascii code for the digit pressed. 
+	#
+	# Command Reference:  SAY DIGITS <number> <escape digits>
+	#
+	public
+	def say_digits(digit_string, escape_digits=nil)
+		escape_digits = sanitize_escape_digits(escape_digits)
+
+		cmd = "SAY DIGITS #{digit_string.to_s} #{escape_digits}" 
+		rs = exec_command(cmd, SayDigits)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Say a given number, returning early if any of the given DTMF digits are received on the channel.
+	#
+	# <b>Parameters</b>
+	# - number			: number to announce
+	# - escape_digit	: if pressed, return from program
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# failure: 200 result=-1
+	# success: 200 result=0
+	# digit pressed: 200 result=<digit>
+	#<digit> is the ascii code for the digit pressed. 
+	#
+	# Command Reference:  SAY NUMBER <number> <escape digits>
+	#
+	public
+	def say_number(number, escape_digits=nil)
+		escape_digits = sanitize_escape_digits(escape_digits)
+		cmd = "SAY NUMBER #{number.to_s} #{escape_digits.to_s}"
+		rs = exec_command(cmd, SayNumber)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Say a given character string with phonetics, returning early if any of the given DTMF digits are received on the channel.
+	#
+	# <b>Parameters</b>
+	# - string			: character string to announce 
+	# - escape_digit	: digit to be pressed to escape from program 
+	#
+	# <b>Returns</b>
+	# - ReturnStatus (object)
+	#	
+	# failure: 200 result=-1
+	# success: 200 result=0
+	# digit pressed: 200 result=<digit>
+	# <digit> is the ascii code for the digit pressed.
+	#
+	# Command Reference: SAY PHONETIC <string> <escape digits>
+	#
+	public
+	def say_phonetic(string, escape_digits=nil)
+		escape_digits = sanitize_escape_digits(escape_digits)
+		cmd = "SAY PHONETIC #{string.to_s} #{escape_digits}"
+		rs = exec_command(cmd, SayPhonetic)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Say a given time, returning early if any of the given DTMF digits are received on the channel.
+	#
+	# <b>Parameters</b>
+	# - time			: number of seconds elapsed since 00:00:00 on January 1, 1970, Coordinated Universal Time (UTC).
+	# - escape_digits	: digit to be pressed to escape from the program
+	#
+	# <b>Returns</b>
+	# - ReturnStatus (object)
+	#
+	# failure: 200 result=-1
+	# success: 200 result=0
+	# digit pressed: 200 result=<digit>
+	# <digit> is the ascii code for the digit pressed.
+	#
+	# Command Reference: SAY TIME <time> <escape digits>
+	#
+	public
+	def say_time(time=Time.now.to_i, escape_digits='#')
+		escape_digits = sanitize_escape_digits(escape_digits)
+		cmd = "SAY TIME #{time.to_s} #{escape_digits.to_s}"
+		rs = exec_command(cmd, SayTime)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Sends the given image on a channel.
+	# Most channels do not support the transmission of images.
+	# Image names should not include extensions.
+	#
+	# <b>Parameters</b>
+	# - image : location of image
+	#
+	# <b>Returns</b>
+	# - ReturnStatus (object)
+	#
+	# failure: 200 result=-1
+	# success: 200 result=0 
+	#
+	# Command Reference: SEND IMAGE <image>
+	#
+	public
+	def send_image(image)
+		cmd = "SEND IMAGE #{image.to_s}"
+		rs = exec_command(cmd, SendImage)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Sends the given text on a channel.
+	# Most channels do not support the transmission of text.
+	# Text consisting of greater than one word should be placed in quotes since the command only accepts a single argument.
+	#
+	# <b>Parameters</b>
+	# - text : text to be send 
+	#
+	# <b>Returns</b>
+	# - ReturnStatus (object)
+	#
+	# failure: 200 result=-1
+	# success: 200 result=0 
+	#
+	# Command Reference: SEND TEXT "<text to send>"
+	#
+	public
+	def send_text(text)
+		cmd = "SEND TEXT #{text.to_s}"
+		rs = exec_command(cmd, SendText)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Changes the callerid of the current channel.
+	#
+	# <b>Parameters</b>
+	# - number : number to be set a callerid
+	#
+	# <b>Returns</b>
+	# - ReturnStatus (object)
+	#
+	# 200 result=1 
+	#	
+	# Command Reference: SET CALLERID <number>
+	#
+	public
+	def set_caller_id(number)
+		cmd = "SET CALLERID #{number.to_s}"
+		rs = exec_command(cmd, SetCallerID)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Sets the context for continuation upon exiting the application.
+	#
+	# <b>Parameters</b>
+	# - context : name of the context
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# 200 result=0
+	# Note: no checking is done to verify that the context is valid.
+	#       Specifying an invalid context will cause the call to drop
+	#
+	# Command Reference: SET CONTEXT <desired context>
+	#
+	public
+	def set_context(context)
+		cmd = "SET CONTEXT #{context.to_s}"
+		rs = exec_command(cmd, SetContext)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Changes the extension for continuation upon exiting the application.
+	#
+	# <b>Parameters</b>
+	# - extension: name or number of extension to be set
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# 200 result=0
+	# Note: no checking is done to verify that the extension extists.
+	#       If the extension does not exist, the PBX will attempt to move to the "i" (invalid) extension.
+	#       If the invalid "i" extension does not exist, the call will drop
+	#
+	# Command Reference: SET EXTENSION <new extension>
+	#
+	public
+	def set_extension(extension)
+		cmd = "SET EXTENSION #{extension.to_s}"
+		rs = exec_command(cmd, SetExtension)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Enables/Disables the music on hold generator.
+	#
+	# <b>Parameters</b>
+	# - mode		: on or off
+	# - moh_class	: name of the music on hold class 
+	#                 'default' for not provided or nil
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# 200 result=0 
+	# Command Reference: SET MUSIC <on|off> <class>
+	#
+	public
+	def set_music(mode=true, moh_class='default')
+		if ((mode == true) or (not (mode == 0)))
+			mode = 'ON'
+		else
+			mode = 'OFF'
+		end
+		cmd = "SET MUSIC #{mode.to_s} #{moh_class.to_s}"
+		rs = exec_command(cmd, SetMusic)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Changes the priority for continuation upon exiting the application.
+	#
+	# <b>Parameters</b>
+	# - priority : number of priority
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# 200 result=0 
+	# Command Reference: SET PRIORITY <num>
+	#
+	public
+	def set_priority(priority)
+		cmd = "SET PRIORITY #{priority.to_s}"
+		rs = exec_command(cmd, SetPriority)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+    # set variable: Sets a channel variable
+	# These variables live in the channel Asterisk creates
+	# when you pickup a phone and as such they are both local
+	# and temporary. Variables created in one channel can not
+	# be accessed by another channel. When you hang up the phone,
+	# the channel is deleted and any variables in that channel are deleted as well. 
+	#
+	# <b>Parameters</b>
+	# - variablename	: name of the variable
+	# - value			: value to be set for the variable 
+	#
+	# <b>Returns</b> 
+	# - ReturnStatus object
+	#
+	# 200 result=1 
+	# Command Reference: SET VARIABLE <variablename> <value> 
+	#
+	public
+	def set_variable(name, value)
+		cmd = "SET VARIABLE #{name.to_s} \"#{value.to_s}\""
+		rs = exec_command(cmd, SetVariable)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+
+	#
+	# stream file: Sends audio file on channel
+	# Send the given file, allowing playback to be interrupted by the given digits, if any. 
+	# Use double quotes for the digits if you wish none to be permitted. 
+	# If sample offset is provided then the audio will seek to sample offset before play starts. 
+	# Remember, the file extension must not be included in the filename. 
+	# 
+	# <b>Parameters</b>
+	# - filename	: location of the file to be played
+	# - escape_digit: digit to be pressed to escape from playback
+	#
+	# <b>Returns</b> 
+	# - ReturnStatus object
+	#
+	# failure: 200 result=-1 endpos=<sample offset> 
+	# failure on open: 200 result=0 endpos=0 
+	# success: 200 result=0 endpos=<offset> 
+	# digit pressed: 200 result=<digit> endpos=<offset> 
+	# <offset> is the stream position streaming stopped. If it equals <sample offset> there was probably an error. 
+	# <digit> is the ascii code for the digit pressed. 
+	# Command Reference: STREAM FILE <filename> <escape digits> [sample offset] 
+	#
+	public
+	def stream_file(filename, escape_digits='#')
+
+		escape_digits = sanitize_escape_digits(escape_digits)
+		
+		cmd = "STREAM FILE #{filename.to_s} #{escape_digits}"
+		rs = exec_command(cmd, StreamFile)
+		raise CommandError, rs.to_s if rs.command_error?
+
+		return rs
+	end
+
+	#
+    # tdd mode: Activates TDD mode on channels supporting it, to enable communication with TDDs.
+	# Enable/Disable TDD transmission/reception on a channel. 
+	# This function is currently (01July2005) only supported on Zap channels. 
+	# As of 02July2005, this function never returns 0 (Not Capable).
+	# If it fails for any reason, -1 (Failure) will be returned, otherwise 1 (Success) will be returned.
+	# The capability for returning 0 if the channel is not capable of TDD MODE is a future plan. 
+	# 
+	# <b>Parameters</b>
+	# - mode : mode of the tdd to be set
+	#          set tdd on if non-zero or 'true' specified
+	#
+	# <b>Returns</b> 
+	# - ReturnStatus object
+	#
+	# failure: 200 result=-1 
+	# not capable: 200 result=0 
+	# success: 200 result=1
+	# Command Reference: TDD MODE <on|off|mate> 
+	#
+	public
+	def tdd_mode(mode=true)
+		if ((mode == true) or ( not (mode == 1)))
+			mode = 'ON'
+		else
+			mode = 'OFF'
+		end
+		cmd = "TDD MODE #{mode.to_s}"
+		rs = exec_command(cmd, TDDMode)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# Sends <message> to the console via verbose message system. 
+	# The Asterisk verbosity system works as follows.
+	# The Asterisk user gets to set the desired verbosity at startup time
+	# or later using the console 'set verbose' command.
+	# Messages are displayed on the console if their verbose level
+	# is less than or equal to desired verbosity set by the user.
+	# More important messages should have a low verbose level;
+	# less important messages should have a high verbose level. 
+	#
+	# <b>Parameters</b>
+	# - message : message to be send as log
+	# - level   : verbose level to be set
+	#             [level] is the the verbose level (1-4)
+	#             If you specify a verbose level less than 1 or greater than 4, the verbosity is 1.
+	#             The default verbosity seems to be 0 (in 1.0.8),
+	#             and supplying a 0 (zero) verbosity does work:
+	#             the message will be displayed regardless of the console verbosity setting. 
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# 200 result=1 
+	# Command Reference: VERBOSE <message> [level] 
+	# 
+	public
+	def verbose(message, level=3)
+		cmd = "VERBOSE \"#{message.to_s}\" #{level.to_s}"
+		rs = exec_command(cmd, Verbose)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+    # wait for digit: Waits for a digit to be pressed 
+	# Waits up to <timeout> milliseconds for channel to receive a DTMF digit. 
+	# 
+	# <b>Parameters</b>
+	# - timeout : maximum allow waiting time in seconds to get input
+	#             nil, zero or negative would be considered as infinite wait time
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# failure: 200 result=-1 
+	# timeout: 200 result=0 
+	# success: 200 result=<digit> 
+	# <digit> is the ascii code for the digit received. 
+	# Command Reference: WAIT FOR DIGIT <timeout> 
+	#
+	public
+	def wait_for_digit(timeout=nil)
+		timeout = sanitize_timeout(timeout)
+		
+		cmd = "WAIT FOR DIGIT #{timeout.to_s}"
+		rs = exec_command(cmd, WaitForDigit)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	#
+	# method to dial out
+	#
+	# <b>Parameters</b>
+	# - telephone_number	: telephone_number or extension to dial
+	# - protocol			: protocol to be used to make this call
+	# - username			: username to be used to make this call using the specified protocol
+	# - context				: name of the context to be used for authentication
+	# - timeout				: maximum allowed time in seconds to make this call
+	# - options				: options to be passed in 'Dial' command
+	#
+	# <b>Returns</b>
+	# - ReturnStatus object
+	#
+	# Command Reference: Dial(type/identifier,timeout,options,URL) 
+	#
+	def dial(telephone_number=nil, protocol=nil, username=nil, context='default', timeout=nil, options=nil)
+		dial_string = nil
+
+		if protocol == 'LOCAL'
+			return nil if (telephone_number.nil? or context.nil?)
+			dial_string = "LOCAL/#{telephone_number}@#{context}"
+		elsif protocol == 'IAX2'
+			return nil if (telephone_number.nil? or username.nil? or context.nil?)
+			telephone_number.strip!
+			dial_string = "IAX2/#{username}@#{context}/#{telephone_number}" 
+		elsif protocol == 'SIP'
+		else
+			return nil
+		end
+
+		timeout.nil? ? dial_string += "|" : dial_string += "|#{timeout}"
+		options.nil? ? dial_string += "|" : dial_string += "|#{options}"
+		rs = exec('DIAL', dial_string)
+		return rs
+	end
+
+	###### Process methods #######
+	
+	public
+	def raw_command(cmd)
+		rs = exec_command(cmd)
+		raise CommandError, rs.to_s if rs.command_error?
+		return rs
+	end
+
+	protected
+	def exec_command(cmd, return_status=nil)
+		rs = nil
+		begin
+			semaphore do
+				$stderr.puts "    -- ruby-agi << #{cmd}" if debug?
+				$stdout.puts cmd
+				responses = $stdin.gets
+				$stderr.puts "    -- ruby-agi >> #{responses}" if debug?
+				if return_status.nil?
+					rs = ReturnStatus.new(cmd, responses)
+				else
+					rs = return_status.new(cmd, responses)
+				end
+			end
+
+		rescue Errno::EPIPE
+			raise HangupError, "Line hung up during command execution!!"
+		end
+
+		return rs
+	end
+
+	protected
+	def sanitize_escape_digits(digits)
+		if digits.nil?
+			digits = "#"	
+		elsif digits.size == 0
+			digits = "X"
+		else
+			digits = digits.to_s
+		end
+
+		return digits	
+	end
+
+	protected
+	def sanitize_timeout(timeout)
+		if timeout.nil? or timeout <= 0
+			timeout = -1
+		else
+			timeout = timeout * 1000
+		end
+		
+		return timeout
+	end
+	
+	protected
+	def sanitize_file_format(format)
+		if format.nil? or format.size == 0
+			format = "gsm"
+		else
+			format = format.to_s
+		end
+
+		return format
+	end
+
+	protected
+	def sanitize_max_digit(max_digit)
+		if ((max_digit.nil?) or (max_digit <= 0))
+			max_digit = ""
+		else
+			max_digit = max_digit.to_i
+		end
+
+		return max_digit
+	end
+
+	############################################
+	###        More synthetic methods        ###
+	############################################
+
+	public
+	def jump_to(context, extension, priority)
+		set_context(context)		if not context.nil?
+		set_extension(extension)	if not extension.nil?
+		set_priority(priority)		if not priority.nil?
+	end
+end