adhearsion 2.6.4 → 3.0.0.beta1

data/lib/adhearsion/translator/asterisk/component/input_component.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+require 'ruby_speech'
+require 'adhearsion/translator/asterisk/component/dtmf_recognizer'
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        module InputComponent
+          def execute
+            validate
+            setup_dtmf_recognizer
+            send_ref
+            start_timers
+          rescue OptionError, ArgumentError => e
+            with_error 'option error', e.message
+          end
+
+          def process_dtmf(digit)
+            @recognizer << digit
+          rescue Celluloid::DeadActorError
+            logger.warn 'DTMF digit received into a dead recognizer. Dropping digit.'
+          end
+
+          def execute_command(command)
+            case command
+            when Adhearsion::Rayo::Component::Stop
+              command.response = true
+              complete Adhearsion::Event::Complete::Stop.new
+            else
+              super
+            end
+          end
+
+          def match(match)
+            complete success_reason(match)
+          end
+
+          def nomatch
+            complete Adhearsion::Rayo::Component::Input::Complete::NoMatch.new
+          end
+
+          def noinput
+            complete Adhearsion::Rayo::Component::Input::Complete::NoInput.new
+          end
+
+          private
+
+          def input_node
+            @component_node
+          end
+
+          def validate
+            raise OptionError, 'A grammar document is required.' unless input_node.grammars.first
+            raise OptionError, 'Only a single grammar is supported.' unless input_node.grammars.size == 1
+            raise OptionError, 'A mode value other than DTMF is unsupported.' unless input_node.mode == :dtmf
+          end
+
+          def setup_dtmf_recognizer
+            @recognizer = DTMFRecognizer.new self,
+                            input_node.grammars.first,
+                            (input_node.initial_timeout || -1),
+                            (input_node.inter_digit_timeout || -1),
+                            input_node.terminator
+          end
+
+          def start_timers
+            @recognizer.start_timers
+          end
+
+          def success_reason(match)
+            nlsml = RubySpeech::NLSML.draw do
+              interpretation confidence: match.confidence do
+                instance match.interpretation
+                input match.utterance, mode: match.mode
+              end
+            end
+            Adhearsion::Rayo::Component::Input::Complete::Match.new :nlsml => nlsml
+          end
+
+          def complete(reason)
+            unregister_dtmf_event_handler
+            send_complete_event reason
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/translator/asterisk/component/mrcp_native_prompt.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require 'adhearsion/translator/asterisk/component/stop_by_redirect'
+require 'adhearsion/translator/asterisk/component/mrcp_recog_prompt'
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        class MRCPNativePrompt < Component
+          include StopByRedirect
+          include MRCPRecogPrompt
+
+          private
+
+          def validate
+            raise OptionError, "The renderer #{renderer} is unsupported." unless renderer == 'asterisk'
+            raise OptionError, "The recognizer #{recognizer} is unsupported." unless recognizer == 'unimrcp'
+
+            raise OptionError, 'A document is required.' unless output_node.render_documents.count > 0
+            raise OptionError, 'Only one document is allowed.' if output_node.render_documents.count > 1
+            raise OptionError, 'Only inline documents are allowed.' if first_doc.url
+            raise OptionError, 'Only one audio file is allowed.' if first_doc.size > 1
+
+            raise OptionError, 'A grammar is required.' unless input_node.grammars.count > 0
+
+            super
+          end
+
+          def renderer
+            (output_node.renderer || :asterisk).to_s
+          end
+
+          def recognizer
+            (input_node.recognizer || :unimrcp).to_s
+          end
+
+          def execute_unimrcp_app
+            execute_app 'MRCPRecog', grammars
+          end
+
+          def first_doc
+            output_node.render_documents.first
+          end
+
+          def audio_filename
+            path = if first_doc.ssml?
+              first_doc.value.children.first.src
+            else
+              first_doc.value.first
+            end.sub('file://', '')
+
+            dir = File.dirname(path)
+            basename = File.basename(path, '.*')
+            if dir == '.'
+              basename
+            else
+              File.join(dir, basename)
+            end
+          end
+
+          def unimrcp_app_options
+            super do |opts|
+              opts[:f] = audio_filename
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/translator/asterisk/component/mrcp_prompt.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'adhearsion/translator/asterisk/component/mrcp_recog_prompt'
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        class MRCPPrompt < Component
+          include StopByRedirect
+          include MRCPRecogPrompt
+
+          private
+
+          def validate
+            raise OptionError, "The renderer #{renderer} is unsupported." unless renderer == 'unimrcp'
+            raise OptionError, "The recognizer #{recognizer} is unsupported." unless recognizer == 'unimrcp'
+            raise OptionError, 'An SSML document is required.' unless output_node.render_documents.count > 0
+            raise OptionError, 'Only one document is allowed.' if output_node.render_documents.count > 1
+            raise OptionError, 'A grammar is required.' unless input_node.grammars.count > 0
+
+            super
+          end
+
+          def renderer
+            (output_node.renderer || :unimrcp).to_s
+          end
+
+          def recognizer
+            (input_node.recognizer || :unimrcp).to_s
+          end
+
+          def execute_unimrcp_app
+            execute_app 'SynthAndRecog', render_doc, grammars
+          end
+
+          def render_doc
+            d = output_node.render_documents.first
+            if d.content_type
+              d.value.to_doc.to_s
+            else
+              d.url
+            end
+          end
+
+          def unimrcp_app_options
+            super do |opts|
+              opts[:vn] = output_node.voice if output_node.voice
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/translator/asterisk/component/mrcp_recog_prompt.rb

@@ -0,0 +1,165 @@
+# encoding: utf-8
+
+require 'ruby_speech'
+require 'adhearsion/translator/asterisk/unimrcp_app'
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        module MRCPRecogPrompt
+          UniMRCPError = Class.new Error
+
+          MRCP_ERRORS = {
+            '004' => 'RECOGNIZE failed due to grammar load failure.',
+            '005' => 'RECOGNIZE failed due to grammar compilation failure.',
+            '006' => 'RECOGNIZE request terminated prematurely due to a recognizer error.',
+            '007' => 'RECOGNIZE request terminated because speech was too early.',
+            '009' => 'Failure accessing a URI.',
+            '010' => 'Language not supported.',
+            '016' => 'Any DEFINE-GRAMMAR error other than grammar-load-failure and grammar-compilation-failure.',
+          }
+
+          def execute
+            setup_defaults
+            validate
+            send_ref
+            execute_unimrcp_app
+            complete
+          rescue ChannelGoneError
+            call_ended
+          rescue UniMRCPError => e
+            complete_with_error e.message
+          rescue RubyAMI::Error => e
+            complete_with_error "Terminated due to AMI error '#{e.message}'"
+          rescue OptionError => e
+            with_error 'option error', e.message
+          end
+
+          private
+
+          def validate
+            [:interrupt_on, :start_offset, :start_paused, :repeat_interval, :repeat_times, :max_time].each do |opt|
+              raise OptionError, "A #{opt} value is unsupported on Asterisk." if output_node.send opt
+            end
+
+            raise OptionError, "An initial-timeout value must be -1 or a positive integer." if @initial_timeout < -1
+            raise OptionError, "An inter-digit-timeout value must be -1 or a positive integer." if @inter_digit_timeout < -1
+            raise OptionError, "A recognition-timeout value must be -1, 0, or a positive integer." if @recognition_timeout < -1
+            raise OptionError, "A max-silence value must be -1, 0, or a positive integer." if @max_silence < -1
+            raise OptionError, "A speech-complete-timeout value must be -1, 0, or a positive integer." if @speech_complete_timeout < -1
+            raise OptionError, "A hotword-max-duration value must be -1, 0, or a positive integer." if @hotword_max_duration < -1
+            raise OptionError, "A hotword-min-duration value must be -1, 0, or a positive integer." if @hotword_min_duration < -1
+            raise OptionError, "A dtmf-terminate-timeout value must be -1, 0, or a positive integer." if @dtmf_terminate_timeout < -1
+            raise OptionError, "An n-best-list-length value must be a positive integer." if @n_best_list_length && @n_best_list_length < 1
+            raise OptionError, "A speed-vs-accuracy value must be a positive integer." if @speed_vs_accuracy && @speed_vs_accuracy < 0
+          end
+
+          def execute_app(app, *args)
+            UniMRCPApp.new(app, *args, unimrcp_app_options).execute @call
+          end
+
+          def unimrcp_app_options
+            {uer: 1, b: (@component_node.barge_in == false ? 0 : 1)}.tap do |opts|
+              opts[:nit] = @initial_timeout if @initial_timeout > -1
+              opts[:dit] = @inter_digit_timeout if @inter_digit_timeout > -1
+              opts[:dttc] = input_node.terminator if input_node.terminator
+              opts[:spl] = input_node.language if input_node.language
+              opts[:ct] = input_node.min_confidence if input_node.min_confidence
+              opts[:sl] = input_node.sensitivity if input_node.sensitivity
+              opts[:t]  = input_node.recognition_timeout if @recognition_timeout > -1
+              opts[:sint]  = input_node.max_silence if @max_silence > -1
+              opts[:sct]  = @speech_complete_timeout if @speech_complete_timeout > -1
+
+              opts[:sva] = @speed_vs_accuracy if @speed_vs_accuracy
+              opts[:nb] = @n_best_list_length if @n_best_list_length
+              opts[:sit] = @start_input_timers unless @start_input_timers.nil?
+              opts[:dtt] = @dtmf_terminate_timeout if @dtmf_terminate_timeout > -1
+              opts[:sw] = @save_waveform unless @save_waveform.nil?
+              opts[:nac] = @new_audio_channel unless @new_audio_channel.nil?
+              opts[:rm] = @recognition_mode if @recognition_mode
+              opts[:hmaxd] = @hotword_max_duration if @hotword_max_duration > -1
+              opts[:hmind] = @hotword_min_duration if @hotword_min_duration > -1
+              opts[:cdb] = @clear_dtmf_buffer unless @clear_dtmf_buffer.nil?
+              opts[:enm] = @early_no_match unless @early_no_match.nil?
+              opts[:iwu] = @input_waveform_uri if @input_waveform_uri
+              opts[:mt] = @media_type if @media_type
+
+              yield opts
+            end
+          end
+
+          def setup_defaults
+            @initial_timeout = input_node.initial_timeout || -1
+            @inter_digit_timeout = input_node.inter_digit_timeout || -1
+            @recognition_timeout = input_node.recognition_timeout || -1
+            @max_silence = input_node.max_silence || -1
+            @speech_complete_timeout = input_node.headers['Speech-Complete-Timeout'] || -1
+            @speed_vs_accuracy = input_node.headers['Speed-Vs-Accuracy']
+            @n_best_list_length = input_node.headers['N-Best-List-Length']
+            @start_input_timers = input_node.headers['Start-Input-Timers']
+            @dtmf_terminate_timeout = input_node.headers['DTMF-Terminate-Timeout'] || -1
+            @save_waveform = input_node.headers['Save-Waveform']
+            @new_audio_channel = input_node.headers['New-Audio-Channel']
+            @recognition_mode = input_node.headers['Recognition-Mode']
+            @hotword_max_duration = input_node.headers['Hotword-Max-Duration'] || -1
+            @hotword_min_duration = input_node.headers['Hotword-Min-Duration'] || -1
+            @clear_dtmf_buffer = input_node.headers['Clear-DTMF-Buffer']
+            @early_no_match = input_node.headers['Early-No-Match']
+            @input_waveform_uri = input_node.headers['Input-Waveform-URI']
+            @media_type = input_node.headers['Media-Type']
+          end
+
+          def grammars
+            input_node.grammars.map do |d|
+              if d.content_type
+                d.value.to_doc.to_s
+              else
+                d.url
+              end
+            end.join ','
+          end
+
+          def first_doc
+            output_node.render_documents.first
+          end
+
+          def audio_filename
+            first_doc.value.first
+          end
+
+          def output_node
+            @component_node.output
+          end
+
+          def input_node
+            @component_node.input
+          end
+
+          def complete
+            case @call.channel_var('RECOG_STATUS')
+            when 'INTERRUPTED'
+              send_complete_event Adhearsion::Rayo::Component::Input::Complete::NoMatch.new
+            when 'ERROR'
+              raise UniMRCPError
+            else
+              send_complete_event case cause = @call.channel_var('RECOG_COMPLETION_CAUSE')
+              when '000', '008', '012'
+                nlsml = RubySpeech.parse URI.decode(@call.channel_var('RECOG_RESULT'))
+                Adhearsion::Rayo::Component::Input::Complete::Match.new nlsml: nlsml
+              when '001', '003', '013', '014', '015'
+                Adhearsion::Rayo::Component::Input::Complete::NoMatch.new
+              when '002', '011'
+                Adhearsion::Rayo::Component::Input::Complete::NoInput.new
+              when *MRCP_ERRORS.keys
+                raise UniMRCPError, MRCP_ERRORS[cause]
+              else
+                raise UniMRCPError
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/translator/asterisk/component/output.rb

@@ -0,0 +1,233 @@
+# encoding: utf-8
+
+require 'ruby_speech'
+require 'active_support/core_ext/string/filters'
+require 'adhearsion/translator/asterisk/unimrcp_app'
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        class Output < Component
+          include StopByRedirect
+
+          UnrenderableDocError  = Class.new OptionError
+          UniMRCPError          = Class.new Error
+          PlaybackError         = Class.new Error
+
+          def execute
+            raise OptionError, 'An SSML document is required.' unless @component_node.render_documents.first.value
+            raise OptionError, 'An interrupt-on value of speech is unsupported.' if @component_node.interrupt_on == :voice
+
+            [:start_offset, :start_paused, :repeat_interval, :max_time].each do |opt|
+              raise OptionError, "A #{opt} value is unsupported on Asterisk." if @component_node.send opt
+            end
+
+            @early = !@call.answered?
+
+            rendering_engine = @component_node.renderer || :asterisk
+
+            repeat_times = @component_node.repeat_times || 1
+            repeat_times = 1000 if repeat_times.zero?
+
+            case rendering_engine.to_sym
+            when :asterisk
+              validate_audio_only
+              setup_for_native
+
+              repeat_times.times do
+                render_docs.each do |doc|
+                  playback(filenames(doc).values) || raise(PlaybackError)
+                end
+              end
+            when :native_or_unimrcp
+              setup_for_native
+
+              repeat_times.times do
+                render_docs.each do |doc|
+                  doc.value.children.each do |node|
+                    case node
+                    when RubySpeech::SSML::Audio
+                      playback([path_for_audio_node(node)]) || render_with_unimrcp(fallback_doc(doc, node))
+                    when String
+                      if node.include?(' ')
+                        render_with_unimrcp(copied_doc(doc, node))
+                      else
+                        playback([node]) || render_with_unimrcp(copied_doc(doc, node))
+                      end
+                    else
+                      render_with_unimrcp(copied_doc(doc, node.node))
+                    end
+                  end
+                end
+              end
+            when :unimrcp
+              send_progress_if_necessary
+              send_ref
+              repeat_times.times do
+                render_with_unimrcp(*render_docs)
+              end
+            when :swift
+              send_progress_if_necessary
+              send_ref
+              @call.execute_agi_command 'EXEC Swift', swift_doc
+            else
+              raise OptionError, "The renderer #{rendering_engine} is unsupported."
+            end
+            send_finish
+          rescue ChannelGoneError
+            call_ended
+          rescue PlaybackError
+            complete_with_error 'Terminated due to playback error'
+          rescue UniMRCPError
+            complete_with_error 'Terminated due to UniMRCP error'
+          rescue RubyAMI::Error => e
+            complete_with_error "Terminated due to AMI error '#{e.message}'"
+          rescue UnrenderableDocError => e
+            with_error 'unrenderable document error', e.message
+          rescue OptionError => e
+            with_error 'option error', e.message
+          end
+
+          def stop_by_redirect(*args)
+            @stopped = true
+            super
+          end
+
+          private
+
+          def setup_for_native
+            raise OptionError, "A voice value is unsupported on Asterisk." if @component_node.voice
+            raise OptionError, 'Interrupt digits are not allowed with early media.' if @early && @component_node.interrupt_on
+
+            case @component_node.interrupt_on
+            when :any, :dtmf
+              interrupt = true
+            end
+
+            send_progress_if_necessary
+
+            if interrupt
+              call.register_handler :ami, [{:name => 'DTMF', [:[], 'End'] => 'Yes'}, {:name => 'DTMFEnd'}] do |event|
+                stop_by_redirect finish_reason
+              end
+            end
+
+            send_ref
+          end
+
+          def send_progress_if_necessary
+            @call.send_progress if @early
+          end
+
+          def validate_audio_only
+            render_docs.each do |doc|
+              filenames doc, -> { raise UnrenderableDocError, 'The provided document could not be rendered. See http://adhearsion.com/docs/common_problems#unrenderable-document-error for details.' }
+            end
+          end
+
+          def path_for_audio_node(node)
+            path = node.src.sub('file://', '')
+            dir = File.dirname(path)
+            basename = File.basename(path, '.*')
+            if dir == '.'
+              basename
+            else
+              File.join(dir, basename)
+            end
+          end
+
+          def filenames(doc, check_audio_only_policy = -> {})
+            names = {}
+            doc.value.children.each do |node|
+              case node
+              when RubySpeech::SSML::Audio
+                names[node] = path_for_audio_node node
+              when String
+                check_audio_only_policy.call if node.include?(' ')
+                names[nil] = node
+              else
+                check_audio_only_policy.call
+              end
+            end
+            names
+          end
+
+          def playback_options(paths)
+            opts = paths.join '&'
+            opts << ",noanswer" if @early
+            opts
+          end
+
+          def playback(paths)
+            return true if @stopped
+            @call.execute_agi_command 'EXEC Playback', playback_options(paths)
+            @call.channel_var('PLAYBACKSTATUS') != 'FAILED'
+          end
+
+          def fallback_doc(original, failed_audio_node)
+            children = failed_audio_node.nokogiri_children
+            copied_doc original, children
+          end
+
+          def copied_doc(original, elements)
+            doc = RubySpeech::SSML.draw do
+              if Nokogiri.jruby?
+                self.write_attr 'version', original.value['version']
+                self.write_attr 'xml:lang', original.value['xml:lang']
+              else
+                original.value.attributes.each do |name, value|
+                  attr_name = value.namespace && value.namespace.prefix ? [value.namespace.prefix, name].join(':') : name
+                  self.write_attr attr_name, value
+                end
+              end
+
+              add_child Nokogiri.jruby? ? elements : elements.to_xml
+            end
+            Adhearsion::Rayo::Component::Output::Document.new(value: doc)
+          end
+
+          def render_with_unimrcp(*docs)
+            docs.each do |doc|
+              return if @stopped
+              UniMRCPApp.new('MRCPSynth', doc.value.to_s, mrcpsynth_options).execute @call
+              raise UniMRCPError if @call.channel_var('SYNTHSTATUS') == 'ERROR'
+            end
+          end
+
+          def render_docs
+            @component_node.render_documents
+          end
+
+          def concatenated_render_doc
+            render_docs.inject RubySpeech::SSML.draw do |doc, argument|
+              doc + argument.value
+            end
+          end
+
+          def mrcpsynth_options
+            {}.tap do |opts|
+              opts[:i] = 'any' if [:any, :dtmf].include? @component_node.interrupt_on
+              opts[:v] = @component_node.voice if @component_node.voice
+            end
+          end
+
+          def swift_doc
+            doc = concatenated_render_doc.to_s.squish.gsub(/["\\]/) { |m| "\\#{m}" }
+            doc << "|1|1" if [:any, :dtmf].include? @component_node.interrupt_on
+            doc.insert 0, "#{@component_node.voice}^" if @component_node.voice
+            doc
+          end
+
+          def send_finish
+            send_complete_event finish_reason
+          end
+
+          def finish_reason
+            Adhearsion::Rayo::Component::Output::Complete::Finish.new
+          end
+        end
+      end
+    end
+  end
+end