signalwire 1.4.0 → 2.0.0

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Signalwire::Relay::Calling
+  class Action
+    extend Forwardable
+    attr_reader :component
+
+    def_delegators :@component, :control_id, :payload, :completed, :state
+
+    def initialize(component:)
+      @component = component
+    end
+  end
+end

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Signalwire::Relay::Calling
+  class Call
+    include Signalwire::Logger
+    include Signalwire::Common
+    include Signalwire::Blade::EventHandler
+    include Signalwire::Relay::Calling::CallConvenienceMethods
+    extend Forwardable
+
+    attr_reader :device, :type, :node_id, :context, :from, :to,
+                :timeout, :tag, :client, :state, :previous_state, :components,
+                :busy, :failed
+    def_delegators :@client, :relay_execute
+
+    def self.from_event(client, event)
+      new(client, event.call_params)
+    end
+
+    def initialize(client, call_options)
+      @client = client
+
+      @id = call_options[:call_id]
+      setup_call_options(call_options)
+      @type = @device[:type]
+
+      @from = @device[:params][:from_number]
+      @to = @device[:params][:to_number]
+      @timeout = @device[:params][:timeout] || 30
+      @tag = SecureRandom.uuid
+
+      @components = []
+
+      setup_call_event_handlers
+    end
+
+    def setup_call_event_handlers
+      @client.on(:event, proc { |evt| call_match_event(evt) }) do |event|
+        case event.event_type
+        when 'calling.call.connect'
+          change_connect_state(event.call_params[:connect_state])
+        when 'calling.call.state'
+          change_call_state(event.event_params)
+        end
+
+        broadcast :event, event
+        broadcast :state_change, event
+      end
+    end
+
+    def change_call_state(event_params)
+      call_state = event_params[:params]
+      @previous_state = @state
+      @state = call_state[:call_state]
+      broadcast :call_state_change, previous_state: @previous_state, state: @state
+
+      update_call_fields(call_state)
+      broadcast @state.to_sym, previous_state: @previous_state, state: @state
+      finish_call(event_params) if @state == Relay::CallState::ENDED
+    end
+
+    def update_call_fields(call_state)
+      @id = call_state[:call_id] if call_state[:call_id]
+      @node_id = call_state[:node_id] if call_state[:node_id]
+    end
+
+    def change_connect_state(new_connect_state)
+      @previous_connect_state = @connect_state
+      @connect_state = new_connect_state
+      broadcast :connect_state_change, previous_state: @previous_connect_state, state: @connect_state
+    end
+
+    def call_match_event(event)
+      event.event_type.match(/calling\.call/) &&
+        !event.event_type.match(/receive/) &&
+        (event.call_id == id || event.call_params[:tag] == tag)
+    end
+
+    def id
+      @id ||= SecureRandom.uuid
+    end
+
+    def answered?
+      @state == 'answered'
+    end
+
+    def ended?
+      @state == 'ending' || @state == 'ended'
+    end
+
+    def active?
+      !ended?
+    end
+
+    def answer
+      answer_component = Signalwire::Relay::Calling::Answer.new(call: self)
+      answer_component.wait_for(Relay::CallState::ANSWERED, Relay::CallState::ENDING, Relay::CallState::ENDED)
+      AnswerResult.new(component: answer_component)
+    end
+
+    def play(play_object)
+      play_component = Signalwire::Relay::Calling::Play.new(call: self, play: play_object)
+      play_component.wait_for(Relay::CallPlayState::FINISHED, Relay::CallPlayState::ERROR)
+      PlayResult.new(component: play_component)
+    end
+
+    def play!(play_object)
+      play_component = Signalwire::Relay::Calling::Play.new(call: self, play: play_object)
+      play_component.execute
+      PlayAction.new(component: play_component)
+    end
+
+    def prompt(collect_object, play_object)
+      component = Prompt.new(call: self, collect: collect_object, play: play_object)
+      component.wait_for(Relay::CallPromptState::ERROR, Relay::CallPromptState::NO_INPUT, 
+                         Relay::CallPromptState::NO_MATCH, Relay::CallPromptState::DIGIT,
+                         Relay::CallPromptState::SPEECH)
+      PromptResult.new(component: component)
+    end
+
+    def prompt!(collect_object, play_object)
+      component = Prompt,new(call: self, collect: collect_object, play: play_object)
+      component.execute
+      PromptAction.new(component: component)
+    end
+
+    def connect(devices_object)
+      component = Connect.new(call: self, devices: devices_object)
+      component.wait_for(Relay::CallConnectState::CONNECTED, Relay::CallConnectState::FAILED)
+      ConnectResult.new(component: component)
+    end
+
+    def connect!(devices_object)
+      component = Connect.new(call: self, devices: devices_object)
+      component.execute
+      ConnectAction.new(component: component)
+    end
+
+    def record(record_object)
+      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)
+      component = Record.new(call: self, record: record_object)
+      component.execute
+      RecordAction.new(component: component)
+    end
+
+    def hangup(reason = 'hangup')
+      hangup_component = Signalwire::Relay::Calling::Hangup.new(call: self, reason: reason)
+      hangup_component.wait_for(Relay::CallState::ENDED)
+      HangupResult.new(component: hangup_component)
+    end
+
+    def dial
+      dial_component = Signalwire::Relay::Calling::Dial.new(call: self)
+      dial_component.wait_for(Relay::CallState::ANSWERED, Relay::CallState::ENDING, Relay::CallState::ENDED)
+      DialResult.new(component: dial_component)
+    end
+
+    def wait_for(*events)
+      events = [Relay::CallState::ENDED] if events.empty?
+      
+      current_state_index = Relay::CALL_STATES.find_index(@state)
+      max_index = events.map { |evt| Relay::CALL_STATES.find_index(evt) }.max
+
+      return true if current_state_index >= max_index
+
+      component = Await.new(call: self)
+      component.wait_for(*events)
+      component.successful
+    end
+
+    def register_component(component)
+      @components << component
+    end
+
+    def terminate_components(params = {})
+      @components.each do |comp|
+        comp.terminate(params) unless component.completed
+      end
+    end
+
+    def finish_call(params)
+      terminate_components(params)
+      client.calling.end_call(id)
+      @busy = true if params[:reason] == Relay::DisconnectReason::BUSY
+      @failed = true if params[:reason] == Relay::DisconnectReason::FAILED
+      broadcast :ended, previous_state: @previous_state, state: @state
+    end
+
+  private
+
+    def setup_call_options(call_options)
+      @node_id = call_options[:node_id]
+      @context = call_options[:context]
+      @previous_state = nil
+      @state = call_options[:call_state]
+      @previous_connect_state = nil
+      @connect_state = call_options[:connect_state]
+      @device = call_options[:device]
+      @busy = false
+      @failed = false
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module Signalwire::Relay::Calling
+  module CallConvenienceMethods
+    def play_audio(url)
+      play audio_payload(url)
+    end
+
+    def play_audio!(url)
+      play! audio_payload(url)
+    end
+
+    def play_silence(duration)
+      play silence_payload(duration)
+    end
+
+    def play_silence!(duration)
+      play! silence_payload(duration)
+    end
+
+    def play_tts(sentence, language='en-US', gender='female')
+      play tts_payload(sentence, language, gender)
+    end
+
+    def play_tts!(sentence, language='en-US', gender='female')
+      play! tts_payload(sentence, language, gender)
+    end
+
+    def prompt_audio(collect, url)
+      prompt(collect, audio_payload(url))
+    end
+
+    def prompt_audio!(collect, url)
+      prompt!(collect, audio_payload(url))
+    end
+
+    def prompt_silence(collect, duration)
+      prompt(collect, silence_payload(duration))
+    end
+
+    def prompt_silence!(collect, url)
+      prompt!(collect, silence_payload(duration))
+    end
+
+    def prompt_tts(collect, sentence, language='en-US', gender='female')
+      prompt(collect, tts_payload(sentence, language, gender))
+    end
+
+    def prompt_tts!(collect, sentence, language='en-US', gender='female')
+      prompt!(collect, tts_payload(sentence, language, gender))
+    end
+
+    def wait_for_ringing
+      wait_for(Relay::CallState::RINGING)
+    end
+
+    def wait_for_answered
+      wait_for(Relay::CallState::ANSWERED)
+    end
+
+    def wait_for_ending
+      wait_for(Relay::CallState::ENDING)
+    end
+
+    def wait_for_ended
+      wait_for(Relay::CallState::ENDED)
+    end
+
+    def audio_payload(url)
+      [{ type: "audio", params: { url: url } }]
+    end
+
+    def silence_payload(duration)
+      [{ type: "silence", params: { duration: duration } }]
+    end
+
+    def tts_payload(sentence, language='en-US', gender='male')
+      [{ "type": 'tts', "params": { "text": sentence, "language": language, "gender": gender } }]
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Signalwire::Relay::Calling
+  class Component
+    attr_reader :completed, :state, :successful, :event, :execute_result, :call
+
+    def initialize(call:)
+      @call = call
+      @completed = false
+      @successful = false
+
+      @call.register_component(self)
+    end
+
+    # Relay method corresponding to the command
+    #
+    def method
+      raise NotImplementedError, 'Define this method on the child classes'
+    end
+
+    # Relay payload
+    # Implement this on child classes
+    def payload
+      nil
+    end
+
+    # The event type the subclass listens to
+    def event_type
+      raise NotImplementedError, 'Define this method on the child classes'
+    end
+
+    def execute_params(method_suffix = nil)
+      {
+        protocol: @call.client.protocol,
+        method: method + method_suffix.to_s,
+        params: inner_params
+      }
+    end
+
+    def inner_params
+      result = {
+        node_id: @call.node_id,
+        call_id: @call.id
+      }
+      result[:params] = payload if payload
+      result
+    end
+
+    def execute
+      setup_handlers
+      @call.relay_execute execute_params do |event, outcome|
+        handle_execute_result(event, outcome)
+      end
+    end
+
+    def setup_handlers
+      @call.on :event, event_type: event_type do |evt|
+        notification_handler(evt)
+      end
+    end
+
+    def handle_execute_result(event, outcome)
+      @execute_result = event
+      terminate if outcome == :failure
+    end
+
+    def terminate(event = nil)
+      @completed = true
+      @successful = false
+      @state = 'failed'
+      @event = event if event
+      blocker&.reject
+    end
+
+    def setup_waiting_events(events)
+      @events_waiting = events
+    end
+
+    def wait_for(*events)
+      setup_waiting_events(events)
+      execute
+      wait_on_blocker unless @completed
+    end
+
+    def wait_on_blocker
+      create_blocker
+      blocker.wait
+    end
+
+    # This is the most important method to implement in a subclass
+    #
+    def notification_handler(_event)
+      # to be implemented by subclasses. An example could be:
+      #
+      # if event.call_params[:call_state] == 'ended'
+      #   unblock
+      # end
+      raise NotImplementedError, 'Define this method on the child classes'
+    end
+
+    def create_blocker
+      @blocker = Concurrent::Promises.resolvable_future
+    end
+
+    def unblock(value)
+      blocker&.resolve value
+    end
+
+    attr_reader :blocker
+
+    def check_for_waiting_events
+      unblock(event) if @events_waiting.include?(@state)
+    end
+  end
+end