signalwire 2.1.3 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b79e0a17481f2f0fcb5cdf7a1b5860f86565e60826808b3b0c4c671f6797d173
-  data.tar.gz: d798019a441d67cf6d6cdbba6093e13b43353a788465b7333bdf48bf9e0ab969
+  metadata.gz: 325c0f2a81d0a8486fdb356dc91c78284228b30440129ee2a60c3332b1e725b5
+  data.tar.gz: 1f5f8d9227de1b684f05e88d6b1b53246de7f29479c0e11cef94cd792dc8171c
 SHA512:
-  metadata.gz: fcadfef6643451bea578ce6a8fd8355307f53704545c6078e0265ed109c03b7c24b196d25c8703416db25a93ca2aa3158bb49818197294493fa01f43922c054d
-  data.tar.gz: 4cf8ec00e2eb43921000836f1f48012f82e05506c44070960c9b2736d8ffefeb32d5331c8ad5dabe7f537f56bd6a949ef3ab9a70668a3ab8532789dfd4323075
+  metadata.gz: 6362ec6503c1a04505f72b13edfbb29c2bb7ca4002f7e13fd7926099dbac08142254d0a41447c96f2b44a54639fdfb367d12ab710c6a6e628c39143a823e9028
+  data.tar.gz: e8dce6ff15120bc77452aa97667a0aa468d923cd744e0e4ec15c74db0100424b321e9d86438710750d1cb4285f04db4aa3ab1f09f5e93352a2ebfa7c59874edd

data/CHANGELOG.md

@@ -5,6 +5,15 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+## [2.2.0] - 2019-09-09
+### Added
+- `detect_answering_machine` method with its `amd` alias
+
+### Changed
+- Flatten parameter structures for better readability
+- Log all exceptions as errors by default.
+- Deprecated `detect_human` and `detect_machine` methods in favor of `detect_answering_machine`
+
 ## [2.1.3] - 2019-08-20
 ### Fixed
 - Restore the correct parameter for the REST client space URL

data/examples/relay/inbound_send_digits.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+%w[
+  bundler/setup
+  signalwire
+].each { |f| require f }
+
+# Setup your ENV with:
+# SIGNALWIRE_PROJECT_KEY=YOUR_SIGNALWIRE_ACCOUNT_ID
+# SIGNALWIRE_TOKEN=YOUR_SIGNALWIRE_ACCOUNT_TOKEN
+#
+Signalwire::Logger.logger.level = ::Logger::DEBUG
+
+class MyConsumer < Signalwire::Relay::Consumer
+  contexts ['incoming']
+
+  def on_incoming_call(call)
+    call.answer
+    call.send_digits "1234"
+
+    call.hangup
+  rescue StandardError => e
+    logger.error e.inspect
+    logger.error e.backtrace
+  end
+end
+
+MyConsumer.new.run

data/examples/relay/outbound_collect.rb

@@ -13,7 +13,7 @@ class OutboundConsumer < Signalwire::Relay::Consumer
   def ready
     dial_result = client.calling.new_call(from: ENV['FROM_NUMBER'], to: ENV['TO_NUMBER']).dial
     collect_params = { "initial_timeout": 10.0, "digits": { "max": 1, "digit_timeout": 5.0 } }
-    result = dial_result.call.prompt_tts collect: collect_params, text: 'how many hamburgers would you like to order?')
+    result = dial_result.call.prompt_tts collect: collect_params, text: 'how many hamburgers would you like to order?'
 
     dial_result.call.play_tts text: "You ordered #{result.result} hamburgers. Thank you!"
     dial_result.call.hangup

data/examples/relay/outbound_record.rb

@@ -15,7 +15,7 @@ class OutboundConsumer < Signalwire::Relay::Consumer
     call = client.calling.new_call(from: ENV['FROM_NUMBER'], to: ENV['TO_NUMBER'])
     call.dial
     call.play_tts text: 'please leave your message after the beep. Press pound when done.'
-    result = call.record({"audio": { "beep": "true", "terminators": "#"}})
+    result = call.record(beep: true, terminators: "#")
     call.play_tts text: 'you said:'
     call.play_audio result.url
     call.hangup

data/examples/relay/outbound_tap.rb

@@ -14,11 +14,8 @@ class OutboundConsumer < Signalwire::Relay::Consumer
     logger.info 'Dialing out'
     call = client.calling.new_call(from: ENV['FROM_NUMBER'], to: ENV['TO_NUMBER'])
     call.dial
-    
-    tap_arguments = { type: "audio", params: { direction: "listen" } }
-    device_arguments = { type: "rtp", params: { addr: "127.0.0.1", port: 1234 } }
 
-    call.tap_media(tap: tap_arguments, device: device_arguments)
+    call.tap_media(audio_direction: "both", target_addr: "127.0.0.1", target_port: 1234)
 
     call.hangup
   rescue StandardError => e

data/lib/signalwire/blade/event_handler.rb

@@ -9,7 +9,10 @@ module Signalwire::Blade
     alias once register_tmp_handler
 
     def broadcast(event_type, event)
-      trigger_handler event_type, event, broadcast: true
+      trigger_handler event_type, event, broadcast: true, exception_callback: Proc.new { |e| 
+        logger.error "#{e.class}: #{e.message}"
+        logger.error e.backtrace.join("\n")
+      }
     end
   end
 end

data/lib/signalwire/relay.rb

@@ -24,6 +24,7 @@ require 'signalwire/relay/calling/action/prompt_action'
 require 'signalwire/relay/calling/action/record_action'
 require 'signalwire/relay/calling/action/fax_action'
 require 'signalwire/relay/calling/action/tap_action'
+require 'signalwire/relay/calling/action/send_digits_action'
 
 require 'signalwire/relay/calling/result'
 require 'signalwire/relay/calling/result/answer_result'
@@ -36,6 +37,7 @@ require 'signalwire/relay/calling/result/prompt_result'
 require 'signalwire/relay/calling/result/record_result'
 require 'signalwire/relay/calling/result/fax_result'
 require 'signalwire/relay/calling/result/tap_result'
+require 'signalwire/relay/calling/result/send_digits_result'
 
 require 'signalwire/relay/calling/component'
 require 'signalwire/relay/calling/control_component'
@@ -52,6 +54,7 @@ require 'signalwire/relay/calling/component/base_fax'
 require 'signalwire/relay/calling/component/fax_send'
 require 'signalwire/relay/calling/component/fax_receive'
 require 'signalwire/relay/calling/component/tap'
+require 'signalwire/relay/calling/component/send_digits'
 
 require 'signalwire/relay/messaging'
 require 'signalwire/relay/messaging/message'

data/lib/signalwire/relay/calling/action/send_digits_action.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Signalwire::Relay::Calling
+  class SendDigitsAction < Action
+    def result
+      SendDigitsResult.new(@component)
+    end
+  end
+end

data/lib/signalwire/relay/calling/call.rb

@@ -11,6 +11,13 @@ module Signalwire::Relay::Calling
     include Signalwire::Relay::Calling::CallDetectMethods
     extend Forwardable
 
+    extend Gem::Deprecate
+    DETECT_DEPRECATE_MONTH = 10
+    deprecate :detect_human,    :amd, 2019, DETECT_DEPRECATE_MONTH
+    deprecate :detect_human!,   :amd!, 2019, DETECT_DEPRECATE_MONTH
+    deprecate :detect_machine,  :amd, 2019, DETECT_DEPRECATE_MONTH
+    deprecate :detect_machine!, :amd!, 2019, DETECT_DEPRECATE_MONTH
+
     attr_reader :device, :type, :node_id, :context, :from, :to,
                 :timeout, :tag, :client, :state, :previous_state, :components,
                 :busy, :failed, :peer_call
@@ -117,7 +124,12 @@ module Signalwire::Relay::Calling
       PlayAction.new(component: play_component)
     end
 
-    def prompt(collect_p = nil, play_p = nil, collect: nil, play: nil)
+    def prompt(collect_p = nil, play_p = nil, **args)
+
+      collect = args.delete(:collect)
+      play = args.delete(:play)
+
+      collect = compile_collect_arguments(args) if collect.nil? && collect_p.nil?
       set_parameters(binding, %i{collect play}, %i{collect play})
 
       component = Prompt.new(call: self, collect: collect, play: play)
@@ -127,7 +139,8 @@ module Signalwire::Relay::Calling
       PromptResult.new(component: component)
     end
 
-    def prompt!(collect_p = nil, play_p = nil, collect: nil, play: nil)
+    def prompt!(collect_p = nil, play_p = nil, **args)
+      collect = compile_collect_arguments(args) if collect.nil? && collect_p.nil?
       set_parameters(binding, %i{collect play}, %i{collect play})
 
       component = Prompt,new(call: self, collect: collect, play: play)
@@ -147,13 +160,47 @@ module Signalwire::Relay::Calling
       ConnectAction.new(component: component)
     end
 
-    def record(record_object)
+    def record(audio: nil, type: 'audio', beep: false, format: 'mp3', stereo: false, direction: 'speak', initial_timeout: 5, end_silence_timeout: 1, terminators: "#*")
+      if audio.nil?
+        record_object = {
+          "#{type}": 
+          { 
+            beep: beep,
+            format: format,
+            stereo: stereo,
+            direction: direction,
+            initial_timeout: initial_timeout,
+            end_silence_timeout: end_silence_timeout,
+            terminators: terminators
+          } 
+        }
+      else
+        record_object = { "#{type}": audio }
+      end
+
       component = Record.new(call: self, record: record_object)
       component.wait_for(Relay::CallRecordState::NO_INPUT, Relay::CallRecordState::FINISHED)
       RecordResult.new(component: component)
     end
 
-    def record!(record_object)
+    def record!(audio: nil, type: 'audio', beep: false, format: 'mp3', stereo: false, direction: 'speak', initial_timeout: 5, end_silence_timeout: 1, terminators: "#*")
+      if audio.nil?
+        record_object = {
+          "#{type}": 
+          { 
+            beep: beep,
+            format: format,
+            stereo: stereo,
+            direction: direction,
+            initial_timeout: initial_timeout,
+            end_silence_timeout: end_silence_timeout,
+            terminators: terminators
+          } 
+        }
+      else
+        record_object = { "#{type}": audio }
+      end
+
       component = Record.new(call: self, record: record_object)
       component.execute
       RecordAction.new(component: component)
@@ -183,30 +230,54 @@ module Signalwire::Relay::Calling
       FaxAction.new(component: component)
     end
 
-    def fax_send(document: , identity: nil, header: nil)
+    def fax_send(document:, identity: nil, header: nil)
       component = Signalwire::Relay::Calling::FaxSend.new(call: self, document: document, identity: identity, header: header)
       component.wait_for(Relay::CallFaxState::ERROR, Relay::CallFaxState::FINISHED)
       FaxResult.new(component: component)
     end
 
-    def fax_send!(document: , identity: nil, header: nil)
+    def fax_send!(document:, identity: nil, header: nil)
       component = Signalwire::Relay::Calling::FaxSend.new(call: self, document: document, identity: identity, header: header)
       component.execute
       FaxAction.new(component: component)
     end
 
-    def tap_media(tap:, device:)
+    def tap_media(**args)
+      tap = args.delete(:tap)
+      device = args.delete(:device)
+
+      tap = compile_tap_arguments(args) if tap.nil?
+      device = compile_tap_device_arguments(args) if device.nil?
+
       component = Signalwire::Relay::Calling::Tap.new(call: self, tap: tap, device: device)
       component.wait_for(Relay::CallTapState::FINISHED)
       TapResult.new(component: component)
     end
 
-    def tap_media!(tap:, device:)
+    def tap_media!(**args)
+      tap = args.delete(:tap)
+      device = args.delete(:device)
+
+      tap = compile_tap_arguments(args) if tap.nil?
+      device = compile_tap_device_arguments(args) if device.nil?
+      
       component = Signalwire::Relay::Calling::Tap.new(call: self, tap: tap, device: device)
       component.execute
       TapAction.new(component: component)
     end
 
+    def send_digits(digits)
+      component = Signalwire::Relay::Calling::SendDigits.new(call: self, digits: digits)
+      component.wait_for(Relay::CallSendDigitsState::FINISHED)
+      SendDigitsResult.new(component: component)
+    end
+
+    def send_digits!(digits)
+      component = Signalwire::Relay::Calling::SendDigits.new(call: self, digits: digits)
+      component.execute
+      SendDigitsAction.new(component: component)
+    end
+
     def wait_for(*events)
       events = [Relay::CallState::ENDED] if events.empty?
       
@@ -226,7 +297,7 @@ module Signalwire::Relay::Calling
 
     def terminate_components(params = {})
       @components.each do |comp|
-        comp.terminate(params) unless component.completed
+        comp.terminate(params) unless comp.completed
       end
     end
 
@@ -257,8 +328,57 @@ module Signalwire::Relay::Calling
         passed_binding.local_variable_set(x, passed_binding.local_variable_get(x) || passed_binding.local_variable_get("#{x}_p"))
       end
       mandatory_keys.each do |x|
-        raise ArgumentError if passed_binding.local_variable_get(x).nil?
+        raise ArgumentError, "The #{x} argument must be provided" if passed_binding.local_variable_get(x).nil?
       end
     end
+
+    def compile_tap_arguments(args)
+      tap = { params: {} }
+      tap[:type] = args[:media_type] || 'audio'
+      tap[:params][:direction] = args[:audio_direction] if args[:audio_direction]
+      tap[:params][:rate] = args[:rate] if args[:rate]
+      tap[:params][:codec] = args[:codec] if args[:codec]
+      tap
+    end
+
+    def compile_tap_device_arguments(args)
+      device = { params: {} }
+      device[:type] = args[:target_type] || 'rtp'
+      device[:params][:addr] = args[:target_addr] if args[:target_addr]
+      device[:params][:port] = args[:target_port] if args[:target_port]
+      device[:params][:ptime] = args[:target_ptime] if args[:target_ptime]
+      device[:params][:uri] = args[:target_uri] if args[:target_uri]
+      device
+    end
+
+    def compile_collect_arguments(args)
+      generic_fields = %i{initial_timeout partial_results}
+      digit_fields = %i{digits_max digits_terminators digits_timeout}
+      speech_fields = %i{speech_timeout speech_language speech_hints end_silence_timeout}
+      has_digits = (digit_fields & args.keys).any?
+      has_speech = (speech_fields & args.keys).any?
+
+      collect = {}
+      generic_fields.each { |gf| collect[gf] = args[gf] if args[gf] }
+
+      if has_digits
+        digits_obj = {}
+        digits_obj[:max] = args[:digits_max] if args[:digits_max]
+        digits_obj[:terminators] = args[:digits_terminators] if args[:digits_terminators]
+        digits_obj[:digit_timeout] = args[:digits_timeout] if args[:digits_timeout]
+        collect[:digits] = digits_obj
+      end
+
+      if has_speech
+        speech_obj = {}
+        speech_obj[:timeout] = args[:speech_timeout] if args[:speech_timeout]
+        speech_obj[:language] = args[:speech_language] if args[:speech_language]
+        speech_obj[:hints] = args[:speech_hints] if args[:speech_hints]
+        speech_obj[:end_silence_timeout] = args[:end_silence_timeout] if args[:end_silence_timeout]
+        collect[:digits] = digits_obj
+      end
+
+      collect
+    end
   end
 end

data/lib/signalwire/relay/calling/call_convenience_methods.rb

@@ -27,39 +27,64 @@ module Signalwire::Relay::Calling
       play! tts_payload(text, language, gender)
     end
 
-    def prompt_audio(collect_p = nil, url_p = nil, collect: nil, url: nil)
+    def prompt_audio(collect_p = nil, url_p = nil, **args)
+      collect = args.delete(:collect)
+      url = args.delete(:url)
+      collect = compile_collect_arguments(args) if collect.nil? && collect_p.nil?
       set_parameters(binding, %i{collect url}, %i{collect url})
 
-      prompt(collect, audio_payload(url))
+      prompt(collect: collect, play: audio_payload(url))
     end
 
-    def prompt_audio!(collect_p = nil, url_p = nil, collect: nil, url: nil)
+    def prompt_audio!(collect_p = nil, url_p = nil, **args)
+      collect = args.delete(:collect)
+      url = args.delete(:url)
+      collect = compile_collect_arguments(args) if collect.nil? && collect_p.nil?
       set_parameters(binding, %i{collect url}, %i{collect url})
 
-      prompt!(collect, audio_payload(url))
+      prompt!(collect: collect, play: audio_payload(url))
     end
 
-    def prompt_silence(collect_p = nil, duration_p = nil, collect: nil, duration: nil)
+    def prompt_silence(collect_p = nil, duration_p = nil, **args)
+      collect = args.delete(:collect)
+      duration = args.delete(:duration)
+      collect = compile_collect_arguments(args) if collect.nil? && collect_p.nil?
       set_parameters(binding, %i{collect duration}, %i{collect duration})
 
-      prompt(collect, silence_payload(duration))
+      prompt(collect: collect, play: silence_payload(duration))
     end
 
-    def prompt_silence!(collect_p = nil, duration_p = nil, collect: nil, duration: nil)
+    def prompt_silence!(collect_p = nil, duration_p = nil, **args)
+      collect = args.delete(:collect)
+      duration = args.delete(:duration)
+      collect = compile_collect_arguments(args) if collect.nil? && collect_p.nil?
       set_parameters(binding, %i{collect duration}, %i{collect duration})
 
-      prompt!(collect, silence_payload(duration))
+      prompt!(collect: collect, play: silence_payload(duration))
     end
 
-    def prompt_tts(collect_p = nil, text_p = nil, language_p=Relay::DEFAULT_LANGUAGE, gender_p=Relay::DEFAULT_GENDER, collect: nil, text: nil, language: Relay::DEFAULT_LANGUAGE, gender: Relay::DEFAULT_GENDER)
+    def prompt_tts(collect_p = nil, text_p = nil, language_p=Relay::DEFAULT_LANGUAGE, gender_p=Relay::DEFAULT_GENDER, **args)
+      collect = args.delete(:collect)
+      text = args.delete(:text)
+      language = args.delete(:language) || Relay::DEFAULT_LANGUAGE
+      gender = args.delete(:gender) || Relay::DEFAULT_GENDER
+      collect = compile_collect_arguments(args) if collect.nil? && collect_p.nil?
+
       set_parameters(binding, %i{collect text language gender}, %i{collect text})
-      prompt(collect, tts_payload(text, language, gender))
+
+      prompt(collect: collect, play: tts_payload(text, language, gender))
     end
 
-    def prompt_tts!(collect_p = nil, text_p = nil, language_p=Relay::DEFAULT_LANGUAGE, gender_p=Relay::DEFAULT_GENDER, collect: nil, text: nil, language: Relay::DEFAULT_LANGUAGE, gender: Relay::DEFAULT_GENDER)
+    def prompt_tts!(collect_p = nil, text_p = nil, language_p=Relay::DEFAULT_LANGUAGE, gender_p=Relay::DEFAULT_GENDER, **args)
+      collect = args.delete(:collect)
+      text = args.delete(:text)
+      language = args.delete(:language) || Relay::DEFAULT_LANGUAGE
+      gender = args.delete(:gender) || Relay::DEFAULT_GENDER
+      collect = compile_collect_arguments(args) if collect.nil? && collect_p.nil?
+
       set_parameters(binding, %i{collect text language gender}, %i{collect text})
 
-      prompt!(collect, tts_payload(text, language, gender))
+      prompt!(collect: collect, play: tts_payload(text, language, gender))
     end
 
     def wait_for_ringing

data/lib/signalwire/relay/calling/call_detect_methods.rb

@@ -1,110 +1,120 @@
 module Signalwire::Relay::Calling
   module CallDetectMethods
-    def detect(detect:, timeout: Relay::DEFAULT_CALL_TIMEOUT)
-      component = Signalwire::Relay::Calling::Detect.new(call: self, detect: detect, timeout: timeout)
-      component.wait_for(Relay::CallDetectState::FINISHED, Relay::CallDetectState::ERROR)
+
+    def detect(type:, **args)
+      component = build_detect_component(type, args)
+      component.wait_for(Relay::CallDetectState::MACHINE, Relay::CallDetectState::HUMAN,
+        Relay::CallDetectState::UNKNOWN, Relay::CallDetectState::CED, Relay::CallDetectState::CNG)
       DetectResult.new(component: component)
     end
 
-    def detect!(detect:, timeout: Relay::DEFAULT_CALL_TIMEOUT)
-      component = Signalwire::Relay::Calling::Detect.new(call: self, detect: detect, timeout: timeout)
+    def detect!(type:, **args)
+      component = build_detect_component(type, args)
       component.execute
       DetectAction.new(component: component)
     end
 
+    def detect_answering_machine(**args)
+      detect(type: :machine, **args)
+    end
+
+    def detect_answering_machine!(**args)
+      detect!(type: :machine, **args)
+    end
+
+    def amd(**args)
+      detect(type: :machine, **args)
+    end
+
+    def amd!(**args)
+      detect!(type: :machine, **args)
+    end
+
+    # deprecated since version 2.2. Will be deleted in version 3.0.
     def detect_human(params: {}, timeout: Relay::DEFAULT_CALL_TIMEOUT)
       detect = {
         type: Relay::CallDetectType::MACHINE,
         params: params
       }
       component = Signalwire::Relay::Calling::Detect.new(call: self, detect: detect, timeout: timeout)
-      component.wait_for(Relay::CallDetectState::FINISHED, Relay::CallDetectState::ERROR, Relay::CallDetectState::HUMAN)
+      component.wait_for(Relay::CallDetectState::MACHINE, Relay::CallDetectState::UNKNOWN, Relay::CallDetectState::HUMAN)
       DetectResult.new(component: component)
     end
 
+    # deprecated since version 2.2. Will be deleted in version 3.0.
     def detect_human!(params: {}, timeout: Relay::DEFAULT_CALL_TIMEOUT)
       detect = {
         type: Relay::CallDetectType::MACHINE,
         params: params
       }
       component = Signalwire::Relay::Calling::Detect.new(call: self, detect: detect, timeout: timeout)
-      component.setup_waiting_events([Relay::CallDetectState::FINISHED, Relay::CallDetectState::ERROR, Relay::CallDetectState::HUMAN])
+      component.setup_waiting_events([Relay::CallDetectState::MACHINE, Relay::CallDetectState::UNKNOWN, Relay::CallDetectState::HUMAN])
       component.execute
       DetectAction.new(component: component)
     end
 
+    # deprecated since version 2.2. Will be deleted in version 3.0.
     def detect_machine(params: {}, timeout: Relay::DEFAULT_CALL_TIMEOUT)
       detect = {
         type: Relay::CallDetectType::MACHINE,
         params: params
       }
       component = Signalwire::Relay::Calling::Detect.new(call: self, detect: detect, timeout: timeout)
-      component.wait_for(Relay::CallDetectState::FINISHED, Relay::CallDetectState::ERROR, 
-                         Relay::CallDetectState::MACHINE, Relay::CallDetectState::READY,
-                         Relay::CallDetectState::NOT_READY)
+      component.wait_for(Relay::CallDetectState::MACHINE, Relay::CallDetectState::UNKNOWN, Relay::CallDetectState::HUMAN)
       DetectResult.new(component: component)
     end
 
+    # deprecated since version 2.2. Will be deleted in version 3.0.
     def detect_machine!(params: {}, timeout: Relay::DEFAULT_CALL_TIMEOUT)
       detect = {
         type: Relay::CallDetectType::MACHINE,
         params: params
       }
       component = Signalwire::Relay::Calling::Detect.new(call: self, detect: detect, timeout: timeout)
-      component.setup_waiting_events([Relay::CallDetectState::FINISHED, Relay::CallDetectState::ERROR, 
-                                      Relay::CallDetectState::MACHINE, Relay::CallDetectState::READY,
-                                      Relay::CallDetectState::NOT_READY])
+      component.setup_waiting_events([Relay::CallDetectState::MACHINE, Relay::CallDetectState::UNKNOWN, Relay::CallDetectState::HUMAN])
       component.execute
       DetectAction.new(component: component)                                
     end
 
     def detect_fax(tone: nil, timeout: Relay::DEFAULT_CALL_TIMEOUT)
-      detect, events = prepare_fax_arguments(tone)
-
-      component = Signalwire::Relay::Calling::Detect.new(call: self, detect: detect, timeout: timeout)
-      component.wait_for(*events)
-      DetectResult.new(component: component)
+      detect(type: :fax, tone: tone, timeout: timeout)
     end
 
     def detect_fax!(tone: nil, timeout: Relay::DEFAULT_CALL_TIMEOUT)
-      detect, events = prepare_fax_arguments(tone)
-      component = Signalwire::Relay::Calling::Detect.new(call: self, detect: detect, timeout: timeout)
-      component.setup_waiting_events(events)
-      component.execute
-      DetectAction.new(component: component)     
+      detect!(type: :fax, tone: tone, timeout: timeout)    
     end
 
     def detect_digit(digits: nil, timeout: Relay::DEFAULT_CALL_TIMEOUT)
-      detect = {
-        type: Relay::CallDetectType::DIGIT,
-        params: {}
-      }
-      detect[:params][:digits] = digits if digits
-      detect(detect: detect, timeout: timeout)
+      detect(type: :digit, digits: digits, timeout: timeout)
     end
 
     def detect_digit!(digits: nil, timeout: Relay::DEFAULT_CALL_TIMEOUT)
-      detect = {
-        type: Relay::CallDetectType::DIGIT,
-        params: {}
-      }
-      detect[:params][:digits] = digits if digits
-      detect!(detect: detect, timeout: timeout)
+      detect!(type: :digit, digits: digits, timeout: timeout)
     end
 
-    def prepare_fax_arguments(tone)
-      fax_events = [Relay::CallDetectState::CED, Relay::CallDetectState::CNG]
-      events = [Relay::CallDetectState::FINISHED, Relay::CallDetectState::ERROR]
-      detect = { type: Relay::CallDetectType::FAX, params: {} }
+    private 
+
+    def build_detect_component(type, args)
+      detect = args.delete(:detect)
+      timeout = args.delete(:timeout) || Relay::DEFAULT_CALL_TIMEOUT
+      wait_for_beep = args.delete(:wait_for_beep)
 
-      if fax_events.include?(tone)
-        detect[:params] = { tone: tone }
-        events << tone
-      else
-        events = events + fax_events
+      if detect.nil?
+        detect = { params: {} }
+        detect[:type] = type.to_sym || :machine
+        
+        if detect[:type] == :machine
+          %i{initial_timeout end_silence_timeout machine_voice_threshold machine_words_threshold}.each do |key|
+            detect[:params][key] = args[key] if args[key]
+          end
+        elsif detect[:type] == :fax
+          detect[:params][:tone] = args[:tone]
+        elsif detect[:type] == :digit
+          detect[:params][:digits] = args[:digits]
+        end
       end
 
-      [detect, events]
+      component = Signalwire::Relay::Calling::Detect.new(call: self, detect: detect, wait_for_beep: wait_for_beep, timeout: timeout)
     end
   end
 end

data/lib/signalwire/relay/calling/component.rb

@@ -2,13 +2,14 @@
 
 module Signalwire::Relay::Calling
   class Component
+    include Signalwire::Logger
     attr_reader :completed, :state, :successful, :event, :execute_result, :call
 
     def initialize(call:)
       @call = call
       @completed = false
       @successful = false
-
+      @events_waiting = []
       @call.register_component(self)
     end
 
@@ -69,7 +70,7 @@ module Signalwire::Relay::Calling
       @successful = false
       @state = 'failed'
       @event = event if event
-      blocker&.reject
+      blocker&.reject false
     end
 
     def setup_waiting_events(events)
@@ -87,6 +88,10 @@ module Signalwire::Relay::Calling
       blocker.wait
     end
 
+    def has_blocker?
+      !@blocker.nil?
+    end
+
     # This is the most important method to implement in a subclass
     #
     def notification_handler(_event)
@@ -103,7 +108,7 @@ module Signalwire::Relay::Calling
     end
 
     def unblock(value)
-      blocker&.resolve value
+      blocker&.resolve value if has_blocker? && blocker.pending?
     end
 
     attr_reader :blocker

data/lib/signalwire/relay/calling/component/detect.rb

@@ -4,11 +4,16 @@ module Signalwire::Relay::Calling
   class Detect < ControlComponent
     attr_reader :result, :type
 
-    def initialize(call:, detect:, timeout: 30)
+    FINISHED_EVENTS = [Relay::CallDetectState::FINISHED, Relay::CallDetectState::ERROR]
+    MACHINE_EVENTS = [Relay::CallDetectState::READY, Relay::CallDetectState::NOT_READY]
+
+    def initialize(call:, detect:, wait_for_beep: false, timeout: 30)
       super(call: call)
       @detect = detect
       @timeout = timeout
+      @wait_for_beep = wait_for_beep
       @received_events = Concurrent::Array.new
+      @waiting_for_ready = false
     end
 
     def method
@@ -30,33 +35,56 @@ module Signalwire::Relay::Calling
     end
 
     def notification_handler(event)
-      result = event.call_params[:detect]
-      @type = result[:type]
-      params = result[:params]
+      detect_result = event.call_params[:detect]
+      @type = detect_result[:type]
+      params = detect_result[:params]
       res_event = params[:event]
       @state = res_event
 
-      if @state != Relay::CallDetectState::FINISHED && @state != Relay::CallDetectState::ERROR
-        @received_events << res_event
-      end
+      return complete(event) if FINISHED_EVENTS.include?(@state) || @type == Relay::CallDetectType::DIGIT
 
-      @completed = @events_waiting.include?(@state)
+      if has_blocker?
+        @received_events << @state 
+        return
+      end
 
-      if @completed
-        @successful = @state != Relay::CallDetectState::ERROR
-        @result = @received_events.join(' ')
-        @event = event
-        unblock(event)
+      if @waiting_for_ready
+        return (@state == Relay::CallDetectState::READY ? complete(event) : nil)
       end
 
+      if (@wait_for_beep && @state == Relay::CallDetectState::MACHINE)
+        @waiting_for_ready = true
+        return
+      end
+      
+      check_for_waiting_events
       broadcast_event(event)
-      # This component has complex logic so we handle it separately
-      # check_for_waiting_events
     end
 
     def broadcast_event(event)
       @call.broadcast "detect_#{@state}".to_sym, event
       @call.broadcast :detect_state_change, event
     end
+
+    private
+
+    def complete(event)
+      @completed = true
+      @event = event
+      
+      if has_blocker?
+        @successful = !FINISHED_EVENTS.include?(@state)
+
+        if MACHINE_EVENTS.include?(@state)
+          @result = Relay::CallDetectState::MACHINE
+        else
+          @result = @state
+        end
+        unblock(event)
+      else
+        @result = @received_events.join(',')
+        @successful = @state != Relay::CallDetectState::ERROR
+      end
+    end
   end
 end

data/lib/signalwire/relay/calling/component/send_digits.rb

@@ -0,0 +1,45 @@
+module Signalwire::Relay::Calling
+  class SendDigits < ControlComponent
+    def initialize(call:, digits:)
+      super(call: call)
+      @digits = digits
+    end
+
+    def method
+      Relay::ComponentMethod::SEND_DIGITS
+    end
+
+    def event_type
+      Relay::CallNotification::SEND_DIGITS
+    end
+
+    def inner_params
+      {
+        node_id: @call.node_id,
+        call_id: @call.id,
+        control_id: control_id,
+        digits: @digits
+      }
+    end
+
+    def notification_handler(event)
+      @state = event.call_params[:state]
+
+      @completed = @state == Relay::CallSendDigitsState::FINISHED
+      @successful = @completed
+      @event = event
+
+      broadcast_event(event)
+      check_for_waiting_events
+    end
+
+    def broadcast_event(event)
+      @call.broadcast "send_digits_#{@state}".to_sym, event
+      @call.broadcast :send_digits_change, event
+    end
+
+    def stop
+      logger.warn "SendDigits does not implement a stop action"
+    end
+  end
+end

data/lib/signalwire/relay/calling/result/send_digits_result.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Signalwire::Relay::Calling
+  class SendDigitsResult < Result
+  end
+end

data/lib/signalwire/relay/constants.rb

@@ -33,6 +33,7 @@ module Signalwire::Relay
     NO_ANSWER = 'noAnswer'
     DECLINE = 'decline'
     ERROR = 'error'
+    FAILED = 'failed'
   end
 
   module DisconnectSource
@@ -65,6 +66,7 @@ module Signalwire::Relay
     FAX = 'calling.call.fax'
     TAP = 'calling.call.tap'
     DETECT = 'calling.call.detect'
+    SEND_DIGITS = 'calling.call.send_digits'
   end
 
   CALL_EVENT_STATE_FIELDS = {
@@ -117,6 +119,7 @@ module Signalwire::Relay
     RECEIVE_FAX = 'calling.receive_fax'
     TAP = 'calling.tap'
     DETECT = 'calling.detect'
+    SEND_DIGITS = 'calling.send_digits'
   end
 
   module CommonState
@@ -151,6 +154,10 @@ module Signalwire::Relay
     MACHINE = "machine"
     DIGIT = "digit"
   end
+
+  module CallSendDigitsState
+    FINISHED = 'finished'
+  end
 end
 
 Relay = Signalwire::Relay

data/lib/signalwire/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Signalwire
-  VERSION = '2.1.3'
+  VERSION = '2.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: signalwire
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 2.2.0
 platform: ruby
 authors:
 - SignalWire Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-20 00:00:00.000000000 Z
+date: 2019-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -259,6 +259,7 @@ files:
 - examples/relay/fax/fax_send.rb
 - examples/relay/inbound_consumer.rb
 - examples/relay/inbound_dial.rb
+- examples/relay/inbound_send_digits.rb
 - examples/relay/messaging/messaging_receive.rb
 - examples/relay/messaging/messaging_send.rb
 - examples/relay/outbound_collect.rb
@@ -288,6 +289,7 @@ files:
 - lib/signalwire/relay/calling/action/play_action.rb
 - lib/signalwire/relay/calling/action/prompt_action.rb
 - lib/signalwire/relay/calling/action/record_action.rb
+- lib/signalwire/relay/calling/action/send_digits_action.rb
 - lib/signalwire/relay/calling/action/tap_action.rb
 - lib/signalwire/relay/calling/call.rb
 - lib/signalwire/relay/calling/call_convenience_methods.rb
@@ -305,6 +307,7 @@ files:
 - lib/signalwire/relay/calling/component/play.rb
 - lib/signalwire/relay/calling/component/prompt.rb
 - lib/signalwire/relay/calling/component/record.rb
+- lib/signalwire/relay/calling/component/send_digits.rb
 - lib/signalwire/relay/calling/component/tap.rb
 - lib/signalwire/relay/calling/control_component.rb
 - lib/signalwire/relay/calling/result.rb
@@ -317,6 +320,7 @@ files:
 - lib/signalwire/relay/calling/result/play_result.rb
 - lib/signalwire/relay/calling/result/prompt_result.rb
 - lib/signalwire/relay/calling/result/record_result.rb
+- lib/signalwire/relay/calling/result/send_digits_result.rb
 - lib/signalwire/relay/calling/result/tap_result.rb
 - lib/signalwire/relay/client.rb
 - lib/signalwire/relay/constants.rb