Relay SDK for .NET

Getting Started

The Relay SDK for .NET enables .NET developers to connect and use SignalWire's Relay APIs within their own .NET code. Our Relay SDK allows developers to build or add robust and innovative communication services to their applications.

The Relay SDK for .NET is easy to use and only takes a few minute to setup and get running.

Latest Version:

Source Code: signalwire/signalwire-dotnet

Support: SignalWire Community Slack Channel

Installation

Install the package for a .NET Core project using NUGET:

dotnet add package signalwire-dotnet

Or you can install the package through Visual Studio's NUGET package manager, simply install the signalwire-dotnet package to your project.

Minimum Requirements

The .NET SDK may be used with .NET Framework 4.6.1 or greater or .NET Core 2.1 or greater.

Using the SDK

The .NET SDK can be used to get up and running with Relay quickly and easily. In order to use the .NET client, you must get your project and token from your SignalWire dashboard.

There are a few ways to get started, depending on your needs: SignalWire.Relay.Consumer, SignalWire.Relay.Task, and SignalWire.Relay.Client.

Relay Consumer

A SignalWire.Relay.Consumer creates a long running process, allowing you to respond to incoming requests and events in realtime. Relay Consumers abstract all the setup of connecting to Relay and automatically dispatches workers to handle requests; so you can concentrate on writing your code without having to worry about multi-threading or blocking, everything just works. Think of Relay Consumers like a background worker system for all your calling and messaging needs.

Relay Consumers can scale easily, simply by running multiple instances of your SignalWire.Relay.Consumer process. Each event will only be delivered to a single consumer, so as your volume increases, just scale up! This process works well whether you are using Docker Swarm, a Procfile on Heroku, your own webserver, and most other environments.

Setting up a new consumer is the easiest way to get up and running.

using SignalWire.Relay;
using SignalWire.Relay.Calling;
using System;
using System.Collections.Generic;

namespace Example
{
    class ExampleConsumer : Consumer
    {
        protected override void Setup()
        {
            Project = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
            Token = "PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
            Contexts = new List<string> { "test" };
        }

        protected override void OnIncomingCall(Call call)
        {
            AnswerResult resultAnswer = call.Answer();
            if (!resultAnswer.Successful) return;

            call.PlayTTS("Welcome to SignalWire!");

            call.Hangup();
        }
    }

    class Program
    {
        public static void Main()
        {
            new ExampleConsumer().Run();
        }
    }
}

Learn more about Relay Consumers

Relay Task

A SignalWire.Relay.RelayTask is simple way to send jobs to your SignalWire.Relay.Consumer from a short lived process, like a web framework. Relay Tasks allow you to pass commands down to your Consumers without blocking your short lived request. Think of a Relay Task as a way to queue a job for your background workers to processes asynchronously.

For example, if you wanted to make an outbound call and play a message when your user clicks a button on your web application, since Relay is a realtime protocol and relies on you to tell it what to do in realtime, if you did this within your web application, your web server would block until the call was finished... this may take a long time! Instead, simply create a new Relay Task. This task will be handled by a running Relay Consumer process and your web application can respond back to your user immediately.

RelayTask.Deliver(validHost, validProjectID, validToken, validContext, new JObject {
    ["number_to_call"] = "+1555XXXXXXX",
    ["message_to_play"] = "We have a message for you",
});

Learn more about Relay Tasks

Relay Client

SignalWire.Relay.Client is a lower level object, giving you a basic connection to Relay but that is all. It is best used when you are creating a script only concerned with sending outbound requests or you want complete control over the Relay connection yourself.

Setting up a new client and make an outbound call.

using SignalWire.Relay;
using SignalWire.Relay.Calling;
using System;
using System.Threading.Tasks;

namespace Example
{
    internal class Program
    {
        public static void Main()
        {
            using (Client client = new Client("XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX", "PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"))
            {
                // Assign callbacks
                client.OnReady += c =>
                {
                    // This callback cannot block, so create a threaded task
                    Task.Run(() =>
                    {
                        DialResult resultDial = client.Calling.DialPhone("+1XXXXXXXXXX", "+1YYYYYYYYYY");

                        if (resultDial.Successful)
                        {
                            // Your call has been answered, use resultDial.Call to access it
                        }
                    });
                };

                // Connect the client
                client.Connect();

                // Prevent exit until a key is pressed
                Console.Write("Press any key to exit...");
                Console.ReadKey(true);
            }
        }
    }
}

Learn more about Relay Clients

Contexts

Relay uses Contexts as a simple way to separate events to specific consumers, allowing you to write consumers for specific types of calls or messages or scale them independently. A Context is simply a named string, that allows you to categorize requests. When creating outbound requests, or configuring phone numbers for inbound requests, you can specify the context; Relay will then deliver that call or event to Consumers that are configured to listen for that context.

For example, you could have a customer support phone number configured to send to Relay with the support context, and a personal number configured with personal context. Relay would deliver these events to any Consumer listening for those contexts. This gives you a lot of control in how messages are delivered to your Consumers, allowing you to write Consumer classes specific to the context, scale them independently, or separate traffic based on your own business rules.

API Reference

SignalWire.Relay.Consumer

A Relay Consumer is a simple application framework that provides a shell for creating independent consumers of the Relay SDK. Relay Consumers abstract all the setup of connecting to Relay and automatically dispatch workers to handle requests. Consumers will receive requests and delegate them to their own worker thread, allowing you to focus on your business logic without having to worry about multi-threading or blocking, everything just works. Think of Relay Consumers like a background worker system for all your calling and messaging needs.

Creating Consumers

A Relay Consumer is a simple application framework, customized by specifying contexts and event handlers to respond to incoming events.

A consumer has 2 required properties: project, token, and usually requires at least one contexts for incoming events. Project and Token are used to authenticate your Consumer to your SignalWire account. Contexts are a list of contexts you want this Consumer to listen for. Learn more about Contexts.

A consumer is created by inheriting the Consumer type, and then overriding the available methods. It is then executed by initializing and calling the Run method on it.

You can optionally add code to the Setup method if you need to do any initialization work before processing messages. This is useful to do any one-off work that you wouldn't want to do for each and every event, such as setting up logging or connecting to a datastore.

using SignalWire.Relay;
using SignalWire.Relay.Calling;
using System;
using System.Collections.Generic;

namespace Example
{
    internal class ExampleConsumer : Consumer
    {
        protected override void Setup()
        {
            Project = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
            Token = "PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
            Contexts = new List<string> { "test" };

            // Do additional setup here
        }

        protected override void OnIncomingCall(Call call)
        {
            AnswerResult resultAnswer = call.Answer();
            call.PlayTTS("Welcome to SignalWire!");
            call.Hangup();
        }
    }

    internal class Program
    {
        public static void Main()
        {
            new ExampleConsumer().Run();
        }
    }
}

Event Handlers

Event handlers are where you will write most of your code. They are executed when your consumer receives a matching event for the contexts specified by your Consumer.

OnIncomingCall

Executed when you receive an inbound call, passes in the inbound Call object.

Available In:

using SignalWire.Relay;
using SignalWire.Relay.Calling;
using System;
using System.Collections.Generic;

namespace Example
{
    internal class IncomingCallConsumer : Consumer
    {
        protected override void Setup()
        {
            Project = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
            Token = "PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
            Contexts = new List<string> { "test" };
        }

        protected override void OnIncomingCall(Call call)
        {
            AnswerResult resultAnswer = call.Answer();
            call.PlayTTS("Welcome to SignalWire!");
            call.Hangup();
        }
    }

    internal class Program
    {
        public static void Main()
        {
            new IncomingCallConsumer().Run();
        }
    }
}

Ready

Executed when the Consumer has connected and is ready to make Relay requests.

Available In:

using SignalWire.Relay;
using SignalWire.Relay.Messaging;
using System;
using System.Collections.Generic;

namespace Example
{
    internal class ReadyConsumer : Consumer
    {
        protected override void Setup()
        {
            Project = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
            Token = "PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
            Contexts = new List<string> { "test" };
        }

        protected override void Ready(Client client)
        {
            Console.WriteLine("Client ready, sending message...");
            SendResult result = client.Messaging.Send(
                "incoming_context",
                "+1XXXXXXXXXX",
                "+1YYYYYYYYYY",
                new SendSource("Hello from SignalWire!"));

            if (result.Successful)
            {
                Console.WriteLine("Send was successful");
            }
        }
    }

    internal class Program
    {
        public static void Main()
        {
            new ReadyConsumer().Run();
        }
    }
}

OnTask

Executed when a task is received, passes in the RelayTask object.

Available In:

using SignalWire.Relay;
using SignalWire.Relay.Messaging;
using System;
using System.Collections.Generic;

namespace Example
{
    internal class TaskConsumer : Consumer
    {
        protected override void Setup()
        {
            Project = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
            Token = "PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
            Contexts = new List<string> { "test" };
        }

        protected override void OnTask(RelayTask task)
        {
            Console.WriteLine("Task successfully received for project ID {0} at {1} with message '{2}'", task.ProjectID, task.Timestamp, task.Message.ToString());
        }
    }

    internal class Program
    {
        public static void Main()
        {
            new TaskConsumer().Run();
        }
    }
}

OnIncomingMessage

Executed when you receive an inbound message, passes in the inbound Message object.

Available In:

using SignalWire.Relay;
using SignalWire.Relay.Messaging;
using System;
using System.Collections.Generic;

namespace Example
{
    internal class IncomingMessageConsumer : Consumer
    {
        protected override void Setup()
        {
            Project = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
            Token = "PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
            Contexts = new List<string> { "test" };
        }

        protected override void OnIncomingMessage(Message message)
        {
            if (message.Body?.StartsWith("Hello") == true) {
                // ...
            }
        }
    }

    internal class Program
    {
        public static void Main()
        {
            new IncomingMessageConsumer().Run();
        }
    }
}

OnMessageStateChange

Executed when a message state change event comes through. Passes in the Message object.

Available In:

using SignalWire.Relay;
using SignalWire.Relay.Messaging;
using System;
using System.Collections.Generic;

namespace Example
{
    internal class MessageStateChangeConsumer : Consumer
    {
        protected override void Setup()
        {
            Project = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
            Token = "PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
            Contexts = new List<string> { "test" };
        }

        protected override void OnMessageStateChange(Message message)
        {
            if (message.ID == "YYYYYYYY-YYYY-YYYY-YYYY-YYYYYYYYYYYY") {
                // ...
            }
        }
    }

    internal class Program
    {
        public static void Main()
        {
            new MessageStateChangeConsumer().Run();
        }
    }
}

Cleaning Up on Exit

When a Relay Consumer shuts down, you have the opportunity to clean up any resources held by the consumer. For example, you could close any open files, network connections, or send a notification to your monitoring service.

Just implement a Teardown method in your consumer and it will be called during the shutdown procedure.

using SignalWire.Relay;
using SignalWire.Relay.Calling;
using System;
using System.Collections.Generic;

namespace Example
{
    internal class TeardownConsumer : Consumer
    {
        protected override void Setup()
        {
            Project = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
            Token = "PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
            Contexts = new List<string> { "test" };
        }

        protected override void Teardown()
        {
            // Clean up any resources when exiting.
        }

        protected override void OnIncomingCall(Call call)
        {
            AnswerResult resultAnswer = call.Answer();
            call.PlayTTS("Welcome to SignalWire!");
            call.Hangup();
        }
    }

    internal class Program
    {
        // Standard entry point for any C# application
        public static void Main()
        {
            // Create and run the consumer, this will block until the consumer is stopped
            new TeardownConsumer().Run();
        }
    }
}

Running Consumers

Running a consumer is just like running any C# application, simply execute the program as a separate process and ensure you call Run() on the Consumer. The process will stay up until you shut it down.

SignalWire.Relay.Client

SignalWire.Relay.Client is the basic connection to Relay, allowing you send commands to Relay and set up handlers for inbound events.

Constructor

Constructs a client object to interact with Relay.

Parameters

Examples

Create a Client to interact with the Relay API.

Client client = new Client("my-project-id", "my-project-token");

Properties

Methods

Connect

Activates the connection to the Relay API. The connection to Relay does not happen automatically so that you can setup handlers to events that might occur before the connection is successfully established.

Available In:

Returns

void

Examples

// Make sure you have attached the listeners you need before connecting the client, or you might miss some events.
client.Connect()

Disconnect

Disconnect the client from Relay.

Available In:

Returns

void

Examples

client.Disconnect()

Events

All available events you can attach a listener on.

SignalWire.Relay.CallingAPI

This represents the API interface for the Calling Relay Service. This object is used to make requests related to managing end to end calls.

Methods

DialPhone

Make an outbound PhoneCall and waits until it has been answered, times out, busy, or some other error occurs.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.DialResult - The result object to interact with.

Examples

Make an outbound PhoneCall and obtain the Call object after it was answered.

DialResult resultDial = client.Calling.DialPhone("+1XXXXXXXXXX", "+1YYYYYYYYYY", timeout: 30);

if (resultDial.Successful)
{
    // Call has been answered, it is available through resultDial.Call
}

NewPhoneCall

Create a new PhoneCall object. The call has not started, but you can attach event listeners on it.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.PhoneCall - A new call object.

Examples

Create a new PhoneCall object and Dial it.

PhoneCall call = client.Calling.NewPhoneCall("+1XXXXXXXXXX", "+1YYYYYYYYYY", timeout: 30);

call.OnEnded += (a, c, e, p) =>
{
    // Call has been ended
};

DialResult resultDial = call.Dial();

if (resultDial.Successful)
{
    call.Hangup();
}

SignalWire.Relay.Calling.AnswerResult

This object returned from Answer method.

Properties

SignalWire.Relay.Calling.Call

All calls in SignalWire have a common generic interface, Call. A Call is a connection between SignalWire and another device.

Properties

Methods

AMD

Alias for DetectAnsweringMachine.

AMDAsync

Alias for DetectAnsweringMachineAsync.

Answer

Answer an inbound call.

Available In:

Parameters

None

Returns

SignalWire.Relay.Calling.AnswerResult - The result object to interact with.

Examples

Answer an inbound call and check if it was successful.

AnswerResult resultAnswer = call.Answer();
if (resultAnswer.Successful) {
    // The call has been answered
}

Connect

Attempt to connect an existing call to a new outbound call and waits until one of the remote parties answers the call or the connect fails.
This method involves complex nested parameters. You can connect to multiple devices in series, parallel, or any combination of both with creative use of the parameters. Series implies one device at a time, while parallel implies multiple devices at the same time.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.ConnectResult - The result object to interact with.

Examples

Trying to connect a call by calling in series +18991114444 and +18991114445.

ConnectResult resultConnect = call.Connect(new List<List<CallDevice>>
{
    new List<CallDevice>
    {
        new CallDevice
        {
            Type = CallDevice.DeviceType.phone,
            Parameters = new CallDevice.PhoneParams
            {
                ToNumber = "+18991114444",
                FromNumber = "+1YYYYYYYYYY",
                Timeout = 30,
            }
        }
    },
    new List<CallDevice>
    {
        new CallDevice
        {
            Type = CallDevice.DeviceType.phone,
            Parameters = new CallDevice.PhoneParams
            {
                ToNumber = "+18991114445",
                FromNumber = "+1YYYYYYYYYY",
                Timeout = 20,
            }
        }
    }
},
ringback: new List<CallMedia>
{
    new CallMedia
    {
        Type = CallMedia.MediaType.ringtone,
    Parameters = new CallMedia.RingtoneParams
        {
            Name = "us"
        }
    }
});

if (resultConnect.Successful) {
    // The call was connected, and is available at resultConnect.Call
}

Combine serial and parallel calling. Call +18991114443 first and - if it doesn't answer - try calling in parallel +18991114444 and +18991114445. If none of the devices answer, continue the same process with +18991114446 and +18991114447.

ConnectResult resultConnect = call.Connect(new List<List<CallDevice>>
{
    new List<CallDevice>
    {
        new CallDevice
        {
            Type = CallDevice.DeviceType.phone,
            Parameters = new CallDevice.PhoneParams
            {
                ToNumber = "+18991114443",
                FromNumber = "+1YYYYYYYYYY",
                Timeout = 30,
            }
        }
    },
    new List<CallDevice>
    {
        new CallDevice
        {
            Type = CallDevice.DeviceType.phone,
            Parameters = new CallDevice.PhoneParams
            {
                ToNumber = "+18991114444",
                FromNumber = "+1YYYYYYYYYY",
                Timeout = 30,
            }
        },
        new CallDevice
        {
            Type = CallDevice.DeviceType.phone,
            Parameters = new CallDevice.PhoneParams
            {
                ToNumber = "+18991114445",
                FromNumber = "+1YYYYYYYYYY",
                Timeout = 20,
            }
        }
    },
    new List<CallDevice>
    {
        new CallDevice
        {
            Type = CallDevice.DeviceType.phone,
            Parameters = new CallDevice.PhoneParams
            {
                ToNumber = "+18991114446",
                FromNumber = "+1YYYYYYYYYY",
                Timeout = 30,
            }
        },
        new CallDevice
        {
            Type = CallDevice.DeviceType.phone,
            Parameters = new CallDevice.PhoneParams
            {
                ToNumber = "+18991114447",
                FromNumber = "+1YYYYYYYYYY",
                Timeout = 20,
            }
        }
    }
});

if (resultConnect.Successful) {
    // The call was connected, and is available at resultConnect.Call
}

ConnectAsync

Asynchronous version of Connect. It does not wait the connect to complete or fail, but returns a ConnectAction object you can interact with.

Available In:

Parameters

See Connect for the parameter list.

Returns

SignalWire.Relay.Calling.ConnectAction - The action object to interact with.

Examples

Trying to connect a call by calling in series +18991114444 and +18991114445.

ConnectAction actionConnect = call.ConnectAsync(new List<List<CallDevice>>
{
    new List<CallDevice>
    {
        new CallDevice
        {
            Type = CallDevice.DeviceType.phone,
            Parameters = new CallDevice.PhoneParams
            {
                ToNumber = "+18991114444",
                FromNumber = "+1YYYYYYYYYY",
                Timeout = 30,
            }
        }
    },
    new List<CallDevice>
    {
        new CallDevice
        {
            Type = CallDevice.DeviceType.phone,
            Parameters = new CallDevice.PhoneParams
            {
                ToNumber = "+18991114445",
                FromNumber = "+1YYYYYYYYYY",
                Timeout = 20,
            }
        }
    }
});

// Do other stuff while the call is being connected

if (actionConnect.Completed && actionConnect.Result.Successful) {
    // The call was connected, and is available at actionConnect.Result.Call
}

Detect

Run a detector on the call and waits until the first detect update comes through. This is a general method for all types of detecting, see `DetectAnsweringMachine, DetectDigit, or DetectFax for more specific usage.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.DetectResult - The result object to interact with.

Examples

Start a detector and if successful, checks whether the Type is human from the SignalWire.Relay.Calling.DetectResult object.

DetectResult resultDetect = call.Detect(
    new CallDetect
    {
        Type = CallDetect.DetectType.machine,
        Parameters = new CallDetect.MachineParams
        {
        }
    });

if (resultDetect.Successful)
{
    if (resultDetect.Type == DetectResultType.Human)
    {
        // ...
    }
}

DetectAsync

Asynchronous version of Detect. It does not wait for the detection update but returns a SignalWire.Relay.Calling.DetectAction object you can interact with. This is a general method for all types of detecting, see `DetectAnsweringMachine, DetectDigit, or DetectFax for more specific usage.

Available In:

Parameters

See Detect for the parameter list.

Returns

SignalWire.Relay.Calling.DetectAction - The action object to interact with.

Examples

Start a detector and stop it after 5 seconds.

DetectAction actionDetect = call.DetectAsync(
    new CallDetect
    {
        Type = CallDetect.DetectType.machine,
        Parameters = new CallDetect.MachineParams
        {
        }
    });

Thread.Sleep(5000);

actionDetect.Stop();

DetectAnsweringMachine

This is a helper function that refines the use of Detect. This simplifies detecting machines.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.DetectResult - The result object to interact with.

Examples

Detect machine.

DetectResult resultDetect = call.DetectAnsweringMachine();

DetectAnsweringMachineAsync

Asynchronous version of DetectAnsweringMachine. It does not wait for the first detection update, but returns a SignalWire.Relay.Calling.DetectAction object you can interact with.

Available In:

Parameters

See DetectAnsweringMachine for the parameter list.

Returns

SignalWire.Relay.Calling.DetectAction - The action object to interact with.

Examples

Detect machine and stop after 5 seconds.

// within an asynchronous function ..
DetectAction actionDetect = call.DetectAnsweringMachineAsync();

Thread.Sleep(5000);

actionDetect.Stop();

DetectDigit

This is a helper function that refines the use of Detect. This simplifies detecting DTMF.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.DetectResult - The result object to interact with.

Examples

Detect DTMF digits.

DetectResult resultDetect = call.DetectDigit();

DetectDigitAsync

Asynchronous version of DetectDigit. It does not wait for the first detection update, but returns a SignalWire.Relay.Calling.DetectAction object you can interact with.

Available In:

Parameters

See DetectDigit for the parameter list.

Returns

SignalWire.Relay.Calling.DetectAction - The action object to interact with.

Examples

Detect DTMF digits and stop after 5 seconds.

// within an asynchronous function ..
DetectAction actionDetect = call.DetectDigitAsync();

Thread.Sleep(5000);

actionDetect.Stop();

DetectFax

This is a helper function that refines the use of Detect. This simplifies detecting fax.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.DetectResult - The result object to interact with.

Examples

Detect fax.

DetectResult resultDetect = call.DetectFax();

DetectFaxAsync

Asynchronous version of DetectFax. It does not wait for the first detection update, but returns a SignalWire.Relay.Calling.DetectAction object you can interact with.

Available In:

Parameters

See DetectFax for the parameter list.

Returns

SignalWire.Relay.Calling.DetectAction - The action object to interact with.

Examples

Detect fax and stop after 5 seconds.

// within an asynchronous function ..
DetectAction actionDetect = call.DetectFaxAsync();

Thread.Sleep(5000);

actionDetect.Stop();

DetectHuman

This is a helper function that refines the use of Detect. This simplifies detecting humans.

Deprecated since: Use DetectAnsweringMachine instead.

Parameters

Returns

SignalWire.Relay.Calling.DetectResult - The result object to interact with.

Examples

Detect human.

DetectResult resultDetect = call.DetectHuman();

DetectHumanAsync

Asynchronous version of DetectHuman. It does not wait for the first detection update, but returns a SignalWire.Relay.Calling.DetectAction object you can interact with.

Deprecated since: Use DetectAnsweringMachineAsync instead.

Parameters

See DetectHuman for the parameter list.

Returns

SignalWire.Relay.Calling.DetectAction - The action object to interact with.

Examples

Detect human and stop after 5 seconds.

// within an asynchronous function ..
DetectAction actionDetect = call.DetectHumanAsync();

Thread.Sleep(5000);

actionDetect.Stop();

DetectMachine

This is a helper function that refines the use of Detect. This simplifies detecting machines.

Deprecated since: Use DetectAnsweringMachine instead.

Parameters

Returns

SignalWire.Relay.Calling.DetectResult - The result object to interact with.

Examples

Detect machine.

DetectResult resultDetect = call.DetectMachine();

DetectMachineAsync

Asynchronous version of DetectMachine. It does not wait for the first detection update, but returns a SignalWire.Relay.Calling.DetectAction object you can interact with.

Deprecated since: Use DetectAnsweringMachineAsync instead.

Parameters

See DetectMachine for the parameter list.

Returns

SignalWire.Relay.Calling.DetectAction - The action object to interact with.

Examples

Detect machine and stop after 5 seconds.

// within an asynchronous function ..
DetectAction actionDetect = call.DetectMachineAsync();

Thread.Sleep(5000);

actionDetect.Stop();

Dial

This will start a call that was created with NewPhoneCall (or another call creation method) and waits until the call has been answered or hung up.

Available In:

Parameters

None

Returns

SignalWire.Relay.Calling.DialResult - The result object to interact with.

Examples

PhoneCall call = client.Calling.NewPhoneCall("+1XXXXXXXXXX", "+1YYYYYYYYYY");
DialResult resultDial = call.Dial();
if (resultDial.Successful) {
    // Call has been answered
}

FaxReceive

Wait on a fax to come through the current call.

Available In:

Parameters

None

Returns

SignalWire.Relay.Calling.FaxResult - The result object to interact with.

Examples

Start receiving a fax and check whether it was successful.

FaxResult resultFax = call.FaxReceive();

if (resultFax.Successful)
{
    // ...
}

FaxSendAsync

Asynchronous version of FaxSend. It does not wait for a fax but returns a SignalWire.Relay.Calling.FaxAction object you can interact with.

Available In:

Parameters

See FaxSend for the parameter list.

Returns

SignalWire.Relay.Calling.FaxAction - The action object to interact with.

Examples

Start listening for a fax and stop it after 5 seconds.

FaxAction actionFax = call.FaxSendAsync();

Thread.Sleep(5000);

actionFax.Stop();

FaxSend

Wait on a fax to send to a destination.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.FaxResult - The result object to interact with.

Examples

Send a fax and check whether it was successful.

FaxResult resultFax = call.FaxSend("https://cdn.signalwire.com/fax/dummy.pdf");

if (resultFax.Successful)
{
    // ...
}

FaxSendAsync

Asynchronous version of FaxSend. It does not wait for a fax but returns a SignalWire.Relay.Calling.FaxAction object you can interact with.

Available In:

Parameters

See FaxSend for the parameter list.

Returns

SignalWire.Relay.Calling.FaxAction - The action object to interact with.

Examples

Start sending a fax and stop it after 5 seconds.

FaxAction actionFax = call.FaxSendAsync("https://cdn.signalwire.com/fax/dummy.pdf");

Thread.Sleep(5000);

actionFax.Stop();

Hangup

Hangup the call.

Available In:

Parameters

SignalWire.Relay.Calling.DisconnectReason - The reason for the disconnect, defaulted to hangup.

Returns

SignalWire.Relay.Calling.HangupResult - The result object to interact with.

Examples

Hangup a call and check if it was successful.

HangupResult resultHangup = call.Hangup();
if (resultHangup.Successful) {
    // Call has been disconnected with the default hangup reason
}

Play

Play one or more media to a Call and wait until the playing has ended. This is a general method for all types of playing, see PlayAudio, PlaySilence, PlayTTS, or PlayRingtone for more specific usage.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.PlayResult - The result object to interact with.

Examples

Play multiple media elements in the call.

PlayResult resultPlay = call.Play(
    new List<CallMedia>
    {
        new CallMedia
        {
            Type = CallMedia.MediaType.tts,
            Parameters = new CallMedia.TTSParams
            {
                Text = "Listen to this awesome file!"
            }
        },
        new CallMedia
        {
            Type = CallMedia.MediaType.audio,
            Parameters = new CallMedia.AudioParams
            {
                URL = "https://cdn.signalwire.com/default-music/welcome.mp3"
            }
        },
        new CallMedia
        {
            Type = CallMedia.MediaType.silence,
            Parameters = new CallMedia.SilenceParams
            {
                Duration = 5
            }
        },
        new CallMedia
        {
            Type = CallMedia.MediaType.ringtone,
            Parameters = new CallMedia.RingtoneParams
            {
                Name = "us"
            }
        },
        new CallMedia
        {
            Type = CallMedia.MediaType.tts,
            Parameters = new CallMedia.TTSParams
            {
                Text = "Did you like it?"
            }
        }
    },
    volume: 4.0
);

PlayAsync

Asynchronous version of Play. It does not wait for theplaying to complete, but returns a [SignalWire.Relay.Calling.PlayAction`](#api-reference-signalwire-relay-calling-playaction) object you can interact with.

Available In:

Parameters

See Play for the parameter list.

Returns

SignalWire.Relay.Calling.PlayAction - The action object to interact with.

Examples

Play multiple media elements in the call and stop them after 5 seconds.

PlayAction actionPlay = call.PlayAsync(
    new List<CallMedia>
    {
        new CallMedia
        {
            Type = CallMedia.MediaType.tts,
            Parameters = new CallMedia.TTSParams
            {
                Text = "Listen to this awesome file!"
            }
        },
        new CallMedia
        {
            Type = CallMedia.MediaType.audio,
            Parameters = new CallMedia.AudioParams
            {
                URL = "https://cdn.signalwire.com/default-music/welcome.mp3"
            }
        },
        new CallMedia
        {
            Type = CallMedia.MediaType.silence,
            Parameters = new CallMedia.SilenceParams
            {
                Duration = 5
            }
        },
        new CallMedia
        {
            Type = CallMedia.MediaType.ringtone,
            Parameters = new CallMedia.RingtoneParams
            {
                Name = "us"
            }
        },
        new CallMedia
        {
            Type = CallMedia.MediaType.tts,
            Parameters = new CallMedia.TTSParams
            {
                Text = "Did you like it?"
            }
        }
    },
    volume: 4.0
);

Thread.Sleep(5000);

actionPlay.Stop();

PlayAudio

This is a helper function that refines the use of Play. This simplifies playing an audio file.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.PlayResult - The result object to interact with.

Examples

Play an MP3 file.

PlayResult resultPlay = call.PlayAudio("https://cdn.signalwire.com/default-music/welcome.mp3", volume: 4.0);

PlayAudioAsync

Asynchronous version of PlayAudio. It does not wait for the playing to complete, but returns a SignalWire.Relay.Calling.PlayAction object you can interact with.

Available In:

Parameters

See PlayAudio for the parameter list.

Returns

SignalWire.Relay.Calling.PlayAction - The action object to interact with.

Examples

Play an MP3 file and stop it after 5 seconds.

// within an asynchronous function ..
PlayAction actionPlay = call.PlayAudioAsync("https://cdn.signalwire.com/default-music/welcome.mp3", volume: 4.0);

Thread.Sleep(5000);

actionPlay.Stop();

PlayRingtone

This is a helper function that refines the use of Play. This simplifies playing ringtones.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.PlayResult - The result object to interact with.

Examples

Play a single US ringtone.

PlayResult resultPlay = call.PlayRingtone("us");

PlayRingtoneAsync

Asynchronous version of PlayRingtone. It does not wait for the playing to complete, but returns a SignalWire.Relay.Calling.PlayAction object you can interact with.

Available In:

Parameters

See PlayRingtone for the parameter list.

Returns

SignalWire.Relay.Calling.PlayAction - The action object to interact with.

Examples

Play US ringtone for 60 seconds, if Agent is available, stop the play.

PlayAction actionPlay = call.PlayRingtoneAsync("us", duration: 60);

if (agent.Available()) {
    actionPlay.Stop();
}

PlaySilence

This is a helper function that refines the use of Play. This simplifies playing silence.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.PlayResult - The result object to interact with.

Examples

Play silence for 10 seconds.

PlayResult resultPlay = call.PlaySilence(10);

PlaySilenceAsync

Asynchronous version of PlaySilence. It does not wait for the playing to complete, but returns a SignalWire.Relay.Calling.PlayAction object you can interact with.

Available In:

Parameters

See PlaySilence for the parameter list.

Returns

SignalWire.Relay.Calling.PlayAction - The action object to interact with.

Examples

Play silence for 60 seconds, if Agent is available, stop the play.

PlayAction actionPlay = call.PlaySilenceAsync(60);

if (agent.Available()) {
    actionPlay.Stop();
}

PlayTTS

This is a helper function that refines the use of Play. This simplifies playing TTS.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.PlayResult - The result object to interact with.

Examples

Play TTS.

PlayResult resultPlay = call.PlayTTS("Welcome to SignalWire!", gender: "male", volume: 4.0 });

PlayTTSAsync

Asynchronous version of PlayTTS. It does not wait for the playing to complete, but returns a SignalWire.Relay.Calling.PlayAction object you can interact with.

Available In:

Parameters

See PlayTTS for the parameter list.

Returns

SignalWire.Relay.Calling.PlayAction - The action object to interact with.

Examples

Play TTS and stop it after 3 seconds.

PlayAction actionPlay = call.PlayTTSAsync("Welcome to SignalWire! Making communications easy for everyone!", gender: "male", volume: 4.0 })

Thread.Sleep(3000);

actionPlay.Stop();

Prompt

Play one or more media while collecting user's input from the call at the same time, such as digits and speech.
It waits until the collection succeed or timeout is reached. This is a general method for all types of playing, see PromptAudio or PromptTTS for more specific usage.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.PromptResult - The result object to interact with.

Examples

Ask user to enter their PIN and collect the digits.

PromptResult resultPrompt = call.Prompt(
    new List<CallMedia>
    {
        new CallMedia
        {
            Type = CallMedia.MediaType.tts,
            Parameters = new CallMedia.TTSParams
            {
                Text = "Welcome to SignalWire! Please enter your PIN",
            }
        }
    },
    new CallCollect
    {
        InitialTimeout = 10,
        Digits = new CallCollect.DigitsParams
        {
            Max = 4,
            DigitTimeout = 5,
        }
    },
    volume: 4.0);

if (resultPrompt.Successful)
{
    // The collected input is in resultPrompt.Result
}

PromptAsync

Asynchronous version of Prompt. It does not wait for the collect to complete, but returns a SignalWire.Relay.Calling.PromptAction object you can interact with.

Available In:

Parameters

See Prompt for the parameter list.

Returns

SignalWire.Relay.Calling.PromptAction - The action object to interact with.

Examples

Ask user to enter their PIN and collect the digits.

PromptAction actionPrompt = call.PromptAsync(
    new List<CallMedia>
    {
        new CallMedia
        {
            Type = CallMedia.MediaType.tts,
            Parameters = new CallMedia.TTSParams
            {
                Text = "Welcome to SignalWire! Please enter your PIN",
            }
        },
        new CallMedia
        {
            Type = CallMedia.MediaType.audio,
            Parameters = new CallMedia.AudioParams
            {
                URL = "https://cdn.signalwire.com/default-music/welcome.mp3",
            }
        }
    },
    new CallCollect
    {
        InitialTimeout = 10,
        Digits = new CallCollect.DigitsParams
        {
            Max = 4,
            DigitTimeout = 5,
        }
    },
    volume: 4.0);

// Do other stuff

if (actionPrompt.Completed)
{
    if (actionPrompt.Result.Successful)
    {
        // The collected input is in actionPrompt.Result.Result
    }
}

PromptAudio

This is a helper function that refines the use of Prompt.
This function simplifies playing an audio file while collecting user input from the call, such as digits and speech.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.PromptResult - The result object to interact with.

Examples

Collect user digits while playing an MP3 file.

PromptResult resultPrompt = call.PromptAudio(
    "https://cdn.signalwire.com/default-music/welcome.mp3",
    new CallCollect
    {
        InitialTimeout = 10,
        Digits = new CallCollect.DigitsParams
        {
            Max = 4,
            DigitTimeout = 5,
        }
    },
    volume: 4.0);

if (resultPrompt.Successful)
{
    // The collected input is in resultPrompt.Result
}

PromptAudioAsync

Asynchronous version of PromptAudio. It does not wait for the collection to complete, but returns a SignalWire.Relay.Calling.PromptAction object you can interact with.

Available In:

Parameters

See PromptAudio for the parameter list.

Returns

SignalWire.Relay.Calling.PromptAction - The action object to interact with.

Examples

Collect user digits while playing an MP3 file.

PromptAction actionPrompt = call.PromptAudioAsync(
    "https://cdn.signalwire.com/default-music/welcome.mp3",
    new CallCollect
    {
        InitialTimeout = 10,
        Digits = new CallCollect.DigitsParams
        {
            Max = 4,
            DigitTimeout = 5,
        }
    },
    volume: 4.0);

if (actionPrompt.Completed)
{
    if (actionPrompt.Result.Successful)
    {
        // The collected input is in actionPrompt.Result.Result
    }
}

PromptRingtone

This is a helper function that refines the use of Prompt.
This function simplifies playing ringtones while collecting user input from the call, such as digits and speech.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.PromptResult - The result object to interact with.

Examples

Play a US ringtone once and collect digits.

PromptResult resultPrompt = call.PromptRingtone(
    "us",
    new CallCollect
    {
        InitialTimeout = 10,
        Digits = new CallCollect.DigitsParams
        {
            Max = 4,
            DigitTimeout = 5,
        }
    },
    volume: 4.0);

if (resultPrompt.Successful)
{
    // The collected input is in resultPrompt.Result
}

PromptRingtoneAsync

Asynchronous version of PromptRingtone. It does not wait for the collection to complete, but returns a SignalWire.Relay.Calling.PromptAction object you can interact with.

Available In:

Parameters

See PromptRingtone for the parameter list.

Returns

SignalWire.Relay.Calling.PromptAction - The action object to interact with.

Examples

Play a US ringtone once and collect digits.

PromptAction actionPrompt = call.PromptRingtoneAsync(
    "us",
    new CallCollect
    {
        InitialTimeout = 10,
        Digits = new CallCollect.DigitsParams
        {
            Max = 4,
            DigitTimeout = 5,
        }
    },
    volume: 4.0);

if (actionPrompt.Completed)
{
    if (actionPrompt.Result.Successful)
    {
        // The collected input is in actionPrompt.Result.Result
    }
}

PromptTTS

This is a helper function that refines the use of Prompt.
This function simplifies playing TTS while collecting user input from the call, such as digits and speech.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.PromptResult - The result object to interact with.

Examples

Ask user to enter their PIN and collect the digits.

PromptResult resultPrompt = call.PromptTTS(
    "Welcome to SignalWire! Please enter your PIN",
    new CallCollect
    {
        InitialTimeout = 10,
        Digits = new CallCollect.DigitsParams
        {
            Max = 4,
            DigitTimeout = 5,
        }
    },
    gender: "male",
    volume: 4.0);

if (resultPrompt.Successful)
{
    // The collected input is in resultPrompt.Result
}

PromptTTSAsync

Asynchronous version of PromptTTS. It does not wait for the collection to complete, but returns a SignalWire.Relay.Calling.PromptAction object you can interact with.

Available In:

Parameters

See PromptTTS for the parameter list.

Returns

SignalWire.Relay.Calling.PromptAction - The action object to interact with.

Examples

Ask user to enter their PIN and collect the digits.

PromptAction actionPrompt = call.PromptTTSAsync(
    "Welcome to SignalWire! Please enter your PIN",
    new CallCollect
    {
        InitialTimeout = 10,
        Digits = new CallCollect.DigitsParams
        {
            Max = 4,
            DigitTimeout = 5,
        }
    },
    gender: "male",
    volume: 4.0);

if (actionPrompt.Completed)
{
    if (actionPrompt.Result.Successful)
    {
        // The collected input is in actionPrompt.Result.Result
    }
}

Record

Start recording the call and waits until the recording ends or fails.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.RecordResult - The result object to interact with.

Examples

Start recording audio in the call for both direction in stereo mode, if successful, grab Url, Duration and Size from the SignalWire.Relay.Calling.RecordResult object.

RecordResult resultRecord = call.Record(
    new CallRecord
    {
        Audio = new CallRecord.AudioParams
        {
            Stereo = true,
            Direction = CallRecord.AudioParams.AudioDirection.both,
        }
    });

if (resultRecord.Successful)
{
    // The URL for the recording is available in resultRecord.Url
}

RecordAsync

Asynchronous version of Record. It does not wait for the end of the recording but returns a SignalWire.Relay.Calling.RecordAction object you can interact with.

Available In:

Parameters

See Record for the parameter list.

Returns

SignalWire.Relay.Calling.RecordAction - The action object to interact with.

Examples

Start recording audio in the call for both direction in stereo mode and stop it after 5 seconds.

RecordAction actionRecord = call.RecordAsync(
    new CallRecord
    {
        Audio = new CallRecord.AudioParams
        {
            Stereo = true,
            Direction = CallRecord.AudioParams.AudioDirection.both,
        }
    });

Thread.Sleep(5000);

actionRecord.Stop();

SendDigits

Sends DTMF digits to the other party on the call.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.SendDigitsResult - The result object to interact with.

Examples

Send digits and check whether sending was successful.

SendDigitsResult result = call.SendDigits("123w456W789");

if (result.Successful)
{
    // ...
}

SendDigitsAsync

Asynchronous version of SendDigits. It does not wait for all digits to be sent but returns a SignalWire.Relay.Calling.SendDigitsAction object you can interact with.

Available In:

Parameters

See SendDigits for the parameter list.

Returns

SignalWire.Relay.Calling.SendDigitsAction - The action object to interact with.

Examples

Start sending digits.

SendDigitsAction action = call.SendDigits("123w456W789");

// Do other things

Tap

Start tapping the call and waits until the tap ends or fails.

Available In:

Parameters

Returns

SignalWire.Relay.Calling.TapResult - The result object to interact with.

Examples

Start tapping audio in the call for both directions.

TapResult resultTap = call.Tap(
    new CallTap
    {
        Audio = new CallTap.AudioParams
        {
            Direction = CallTap.AudioParams.AudioDirection.both,
        }
    },
    new CallTapDevice
    {
        Type = CallTapDevice.DeviceType.rtp,
        Parameters = new CallTapDevice.RTPParams
        {
            Address = "1.2.3.4",
            Port = 12345,
        }
    });

if (resultTap.Successful)
{
    // The RTP data is flowing to the device
}

TapAsync

Asynchronous version of Tap. It does not wait for the end of the tapping but returns a TapAction object you can interact with.

Available In:

Parameters

See Tap for the parameter list.

Returns

SignalWire.Relay.Calling.TapAction - The action object to interact with.

Examples

Start tapping audio in the call for both directions and stop it after 5 seconds.

TapAction actionTap = call.TapAsync(
    new CallTap
    {
        Audio = new CallTap.AudioParams
        {
            Direction = CallTap.AudioParams.AudioDirection.both,
        }
    },
    new CallTapDevice
    {
        Type = CallTapDevice.DeviceType.rtp,
        Parameters = new CallTapDevice.RTPParams
        {
            Address = "1.2.3.4",
            Port = 12345,
        }
    });

Thread.Sleep(5000);

actionTap.Stop();

WaitFor

Block until the current state of the call is one of the specified SignalWire.Relay.Calling.CallState values. This is a general method, see WaitForAnswered, WaitForEnded, WaitForEnding, or WaitForRinging for more specific usage.

Available In:

Parameters

Returns

bool - Will have the value true if the state is consistent with one of the provided states or false if a timeout occurred.

Examples

Wait to see if a call is answered

bool stateValid = call.WaitFor(null, CallState.answered);
if (stateValid) {
    // The call is answered
}

WaitForAnswered

This is a helper function that refines the use of WaitFor. Block until the current state of the call is the answered SignalWire.Relay.Calling.CallState.

Available In:

Parameters

Returns

bool - Will have the value true if the state is consistent with the specified SignalWire.Relay.Calling.CallState or false if a timeout occurred.

Examples

Wait to see if a call is answered

bool stateValid = call.WaitForAnswered();
if (stateValid) {
    // The call is answered
}

WaitForEnded

This is a helper function that refines the use of WaitFor. Block until the current state of the call is the ended SignalWire.Relay.Calling.CallState.

Available In:

Parameters

Returns

bool - Will have the value true if the state is consistent with the specified SignalWire.Relay.Calling.CallState or false if a timeout occurred.

Examples

Wait to see if a call is ended

bool stateValid = call.WaitForEnded();
if (stateValid) {
    // The call is ended
}

WaitForEnding

This is a helper function that refines the use of WaitFor. Block until the current state of the call is the ending SignalWire.Relay.Calling.CallState.

Available In:

Parameters

Returns

bool - Will have the value true if the state is consistent with the specified SignalWire.Relay.Calling.CallState or false if a timeout occurred.

Examples

Wait to see if a call is ending

bool stateValid = call.WaitForEnding();
if (stateValid) {
    // The call is ending
}

WaitForRinging

This is a helper function that refines the use of WaitFor. Block until the current state of the call is the ringing SignalWire.Relay.Calling.CallState.

Available In:

Parameters

Returns

bool - Will have the value true if the state is consistent with the specified SignalWire.Relay.Calling.CallState or false if a timeout occurred.

Examples

Wait to see if a call is ringing

bool stateValid = call.WaitForRinging();
if (stateValid) {
    // The call is ringing
}

Events

All these events can be used to track the calls lifecycle and instruct SignalWire on what to do for each different state.

State Events

To track the state of a call.

Connect Events

To track the connect state of a call.

Detect Events

To track a detection.

Fax Events

To track a fax operation.

Play Events

To track a playback state.

Prompt Events

To track a prompt state.

Record Events

To track a recording state.

Send Digits Events

To receive a message when the digits are finished sending.

Tap Events

To track an active tap.

SignalWire.Relay.Calling.CallCollect

This object represents call input that is being collected, multiple things may be collected at the same time such as digits and speech.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallCollect collect = new CallCollect
{
    Digits = new CallCollect.DigitsParams
    {
        Max = 1
    }
};

Properties

Methods

None

Events

None

SignalWire.Relay.Calling.CallCollect.DigitsParams

This object represents the parameters specific to digits collecting.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallCollect collect = new CallCollect
{
    Digits = new CallCollect.DigitsParams
    {
        Max = 1
    }
};

Properties

Methods

None

Events

None

SignalWire.Relay.Calling.CallCollect.SpeechParams

This object represents the parameters specific to speech collecting.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallCollect collect = new CallCollect
{
    Speech = new CallCollect.SpeechParams
    {
        // No required parameters
    }
};

Properties

Methods

None

Events

None

SignalWire.Relay.Calling.CallCollectType

This is an enumeration that represents the different possible types of input collection that can occur.

Values

SignalWire.Relay.Calling.CallConnectState

This is an enumeration that represents the different possible states a connect operation may have.

Values

SignalWire.Relay.Calling.CallDetect

This object represents a call detection.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallDetect detect = new CallDetect
{
    Type = CallDetect.DetectType.machine,
    Parameters = new CallDetect.MachineParams
    {
        // Use default machine detection parameters
    }
};

Properties

Methods

ParametersAs<T>()

This is a helper method to convert the Parameters to the real type.

Available In:

Parameters

Returns

T - This is an instance of the data type resulting from the conversion, see SignalWire.Relay.Calling.CallDetect.DetectType for more information.

Examples

CallDetect.DigitParams digitParams = detect.ParametersAs<CallDetect.DigitParams>();
CallDetect.FaxParams faxParams = detect.ParametersAs<CallDetect.FaxParams>();
CallDetect.MachineParams machineParams = detect.ParametersAs<CallDetect.MachineParams>();

Events

None

SignalWire.Relay.Calling.CallDetect.DetectType

This is an enumeration that represents the possible detection types.

Values

SignalWire.Relay.Calling.CallDetect.DigitParams

This object represents the parameters specific to digit detection.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallDetect detect = new CallDetect
{
    Type = CallDetect.DetectType.digit,
    Parameters = new CallDetect.DigitParams
    {
        // No required parameters
    }
};

Properties

Methods

None

Events

None

SignalWire.Relay.Calling.CallDetect.FaxParams

This object represents the parameters specific to fax detection.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallDetect detect = new CallDetect
{
    Type = CallDetect.DetectType.fax,
    Parameters = new CallDetect.FaxParams
    {
        // No required parameters
    }
};

Properties

Methods

None

Events

None

SignalWire.Relay.Calling.CallDetect.FaxParams.FaxTone

This is an enumeration that represents the possible fax tones.

Values

SignalWire.Relay.Calling.CallDetect.MachineParams

This object represents the parameters specific to machine detection.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallDetect detect = new CallDetect
{
    Type = CallDetect.DetectType.machine,
    Parameters = new CallDetect.MachineParams
    {
        // No required parameters
    }
};

Properties

Methods

None

Events

None

SignalWire.Relay.Calling.CallDevice

This object represents a call device.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallDevice device = new CallDevice
{
    Type = CallDevice.DeviceType.phone,
    Parameters = new CallDevice.PhoneParams
    {
        ToNumber = "+1XXXXXXXXXX",
        FromNumber = "+1YYYYYYYYYY",
    }
};

Properties

Methods

ParametersAs<T>()

This is a helper method to convert the Parameters to the real type.

Available In:

Parameters

Returns

T - This is an instance of the data type resulting from the conversion, see SignalWire.Relay.Calling.CallDevice.DeviceType for more information.

Examples

CallDevice.PhoneParams phoneParams = device.ParametersAs<CallDevice.PhoneParams>();

Events

None

SignalWire.Relay.Calling.CallDevice.DeviceType

This is an enumeration that represents the possible device types.

Values

SignalWire.Relay.Calling.CallDevice.PhoneParams

This object represents the parameters specific to a phone device.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallDevice device = new CallDevice
{
    Type = CallDevice.DeviceType.phone,
    Parameters = new CallDevice.PhoneParams
    {
        ToNumber = "+1XXXXXXXXXX",
        FromNumber = "+1YYYYYYYYYY",
    }
};

Properties

Methods

None

Events

None

SignalWire.Relay.Calling.CallMedia

This object represents a call media that is being played.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallMedia media = new CallMedia
{
    Type = CallMedia.MediaType.tts,
    Parameters = new CallMedia.TTSParams
    {
        Text = "I'm a little teapot"
    }
};

Properties

Methods

ParametersAs<T>()

This is a helper method to convert the Parameters to the real type.

Available In:

Parameters

Returns

T - This is an instance of the data type resulting from the conversion, see SignalWire.Relay.Calling.CallMedia.MediaType for more information.

Examples

CallMedia.AudioParams audioParams = media.ParametersAs<CallMedia.AudioParams>();
CallMedia.TTSParams ttsParams = media.ParametersAs<CallMedia.TTSParams>();
CallMedia.SilenceParams silenceParams = media.ParametersAs<CallMedia.SilenceParams>();
CallMedia.RingtoneParams ringtoneParams = media.ParametersAs<CallMedia.RingtoneParams>();

Events

None

SignalWire.Relay.Calling.CallMedia.AudioParams

This object represents the parameters specific to audio media.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallMedia media = new CallMedia
{
    Type = CallMedia.MediaType.audio,
    Parameters = new CallMedia.AudioParams
    {
        URL = "http://example.somewhere.com/test.wav"
    }
};

Properties

Methods

None

Events

None

SignalWire.Relay.Calling.CallMedia.MediaType

This is an enumeration that represents the possible types of media.

Values

SignalWire.Relay.Calling.CallMedia.RingtoneParams

This object represents the parameters specific to ringtone media.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallMedia media = new CallMedia
{
    Type = CallMedia.MediaType.ringtone,
    Parameters = new CallMedia.RingtoneParams
    {
        Name = "us",
        Duration = 5.0
    }
};

Properties

Methods

None

Events

None

SignalWire.Relay.Calling.CallMedia.SilenceParams

This object represents the parameters specific to silence media.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallMedia media = new CallMedia
{
    Type = CallMedia.MediaType.silence,
    Parameters = new CallMedia.SilenceParams
    {
        Duration = 1.0
    }
};

Properties

Methods

None

Events

None

SignalWire.Relay.Calling.CallMedia.TTSParams

This object represents the parameters specific to tts media.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallMedia media = new CallMedia
{
    Type = CallMedia.MediaType.tts,
    Parameters = new CallMedia.TTSParams
    {
        Text = "I'm a little teapot"
    }
};

Properties

Methods

None

Events

None

SignalWire.Relay.Calling.CallPlayState

This is an enumeration that represents the different possible states a play operation may have.

Values

SignalWire.Relay.Calling.CallRingback

This object represents a call ringback that is being played.

Constructor

The only constructor is the default constructor, properties should all be assigned by initializer or after construction.

Parameters

None

Examples

Basic Example

CallRingback ringbackAudio = new CallRingback
{
     Type = CallRingback.RingbackType.audio,
     Parameters = new CallRingback.AudioParams
     {
          URL = "http://path/to/audio/file"
     }
};

CallRingback ringbackRingtone = new CallRingback
{
     Type = CallRingback.RingbackType.ringtone,
     Parameters = new CallRingback.RingtoneParams
     {
         Name = "us",
         Duration = 30
     }
};

CallRingback ringbackSilence = new CallRingback
{
     Type = CallRingback.RingbackType.silence,
     Parameters = new CallRingback.SilenceParams
     {
         Duration = 30
     }
};

CallRingback ringbackTTS = new CallRingback
{
     Type = CallRingback.RingbackType.tts,
     Parameters = new CallRingback.TTSParams
     {
         Gender = "female",
         Language = "en",
         Text = "I'm a little teapot"
     }
};

Properties

Methods

ParametersAs<T>()

This is a helper method to convert the Parameters to the real type.

Available In:

Parameters

Returns

T - This is an instance of the data type resulting from the conversion, see SignalWire.Relay.Calling.CallRingback.RingbackType for more information.

Examples

CallRingback.AudioParams audioParams = ringbackAudio.ParametersAs<CallRingback.AudioParams>();
CallRingback.RingtoneParams ringtoneParams = ringbackRingtone.ParametersAs<CallRingback.RingtoneParams>
CallRingback.SilenceParams silenceParams = ringbackSilence.ParametersAs<CallRingback.SilenceParams>();
CallRingback.TTSParams ttsParams = ringbackTTS.ParametersAs<CallRingback.TTSParams>();