Machine detection

    You can use the silence parameter in conjunction with the machine_detection feature of the Call API to enable your XML to detect whether a call is answered by voice mail. When silence is set to true, as soon as the voice mail finishes speaking, and there is silence for minSilence milliseconds, the next element in the XML is processed, without waiting for the whole period of length seconds to pass.

    Response

    <Response>
        <Wait length="10" silence="true" minSilence="3000" />
        <Speak>Hello, welcome to the jungle.</Speak>
    </Response>
    

    Example Request

    1
    2
    3
    4
    5
    6
    
    from plivo import plivoxml
    
    response = (plivoxml.ResponseElement().add(
        plivoxml.WaitElement(None).set_length(10).set_min_silence(3000)
        .set_silence(True)).add(plivoxml.SpeakElement('Hello')))
    print(response.to_string())
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    
    require 'rubygems'
    require 'plivo'
    
    include Plivo::XML
    include Plivo::Exceptions
    
    begin
      response = Response.new
    
      params = {
        length: '10',
        silence: true,
        min_silence: '3000'
      }
      response.addWait(params)
    
      speak_body = 'Hello, welcome to the Jungle!'
      response.addSpeak(speak_body)
    
      xml = PlivoXML.new(response)
      puts xml.to_xml
    rescue PlivoXMLError => e
      puts 'Exception: ' + e.message
    end
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    
    var plivo = require('plivo');
    
    var response = plivo.Response();
    
    var params = {
            'length': "10",
            'silence': "true",
            'minSilence': "3000"
    };
    response.addWait(params);
    
    var speak_body = "Hello, welcome to the Jungle!";
    response.addSpeak(speak_body);
    
    console.log(response.toXML());
    
    /*
    Sample Output
    <Response>
        <Wait length="10" silence="true" minSilence="3000"/>
        <Speak>Hello, welcome to the Jungle!</Speak>
    </Response>
    */
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    
    <?php
        require '../vendor/autoload.php';
        use Plivo\XML\Response;
    
        $response = new Response();
    
        $params = array(
            'length' => "10",
            'silence' => "true",
            'minSilence' => "3000"
        );
        $response->addWait($params);
    
        $speak_body = "Hello, welcome to the Jungle!";
        $response->addSpeak($speak_body);
    
        Header('Content-type: text/xml');
        echo($response->toXML());
    
        /*
        Sample Output
    
        <Response>
            <Wait length="10" silence="true" minSilence="3000"/>
            <Speak>Hello, welcome to the Jungle!</Speak>
        </Response>
        */
    ?>
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    
    // Example for wait - machine detection
    package com.plivo.api.xml.samples.wait;
    
    import com.plivo.api.exceptions.PlivoXmlException;
    import com.plivo.api.xml.Response;
    import com.plivo.api.xml.Speak;
    import com.plivo.api.xml.Wait;
    
    
    class MachineDetection {
        public static void main(String[] args) throws PlivoXmlException {
            Response response = new Response()
                    .children(
    
    
                            new Wait()
                                    .length(10)
                                    .minSilence(3000)
                                    .silence(true),
    
    
                            new Speak("Hello")
    
                    );
            System.out.println(response.toXmlString());
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    
    using System;
    using System.Collections.Generic;
    using Plivo.XML;
    
    namespace Plivo
    {
    	class MainClass
    	{
    		public static void Main(string[] args)
    		{
    			Plivo.XML.Response resp = new Plivo.XML.Response();
    			resp.AddWait(new Dictionary<string, string>()
    			{
    				{"length", "10"},
                 {"silence", "true"}, 
                 {"minSilence", "3000"}
    			});
    			resp.AddSpeak("Hello, welcome to the Jungle.", 
                 new Dictionary<string, string>() { });
    			var output = resp.ToString();
    			Console.WriteLine(output);
    
    		}
    	}
    }
    
    
    
    //<Response>
    //  <Wait length = "10" silence="true" minSilence="3000" />
    //  <Speak>Hello, welcome to the Jungle.</Speak>
    //</Response>
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    
    // Example for wait - machine detection
    package main
    
    import "github.com/plivo/plivo-go/xml"
    
    func main() {
    	response := xml.ResponseElement{
    		Contents: []interface{}{
    
    			new(xml.WaitElement).
    				SetLength(10).
    				SetMinSilence(3000).
    				SetSilence(true),
    
    			new(xml.SpeakElement).
    				AddSpeak("Hello"),
    		},
    	}
    	print(response.String())
    }