ECV Video Call iOS SDK [EN]

ECV Video Call iOS SDK

Table of Contents

Introduction

Welcome to the ECV Video Call iOS SDK! This SDK enables you to seamlessly integrate real-time video call functionality into your iOS applications. It handles the complexities of signaling, WebRTC peer connections, media streams, and call state management, allowing you to focus on your application's user interface and business logic.

This repository contains:

Key Features

Getting Started

Prerequisites

1. Add Required Frameworks

Your application needs to include the ECV SDK framework and its required dependencies: WebRTC. You will receive these as .framework files.

2. Explore the Demo Application

The included demo application (ECV175_iOS_DEMO) provides a practical example of SDK integration.

3. Basic SDK Initialization (Conceptual)

// Somewhere in your AppDelegate or a central management object
import ECV175_iOS_SDK

// 1. Define the SDK Configuration (See Configuration for details)
let sdkConfig = ECVSdkConfiguration(
    name: "Environment_Name" // Give it any name that refers to your app or backend
    serviceUrl: "YOUR_SERVICE_URL", // Replace with your actual service URL
    useQueueSocket: true // or false, Make sure this matches your backend version (true for 1.75+, false for 1.5)
    // Optionally override webrtcUrl, signalingUrl, etc.
)

// 2. Initialize the SDK Instance
// It's recommended to have a single instance managed centrally
let ecvSdk = ECVSdk(config: sdkConfig)

// Store this instance for access throughout your app (e.g., in AppDelegate, DI, Singleton)
// Example: MyApp.sdkInstance = ecvSdk

Core Concepts

Demo Application Flow

The demo app follows this basic flow:

Next Steps

Usage Guide

This document provides detailed information about using the ECV Video Call iOS SDK in your application.

SDK Initialization

Basic Initialization

import ECV175_iOS_SDK

// Create SDK configuration
let config = ECVSdkConfiguration(
    name: "Environment_Name" // Give it any name that refers to your app or backend
    serviceUrl: "YOUR_SERVICE_URL",
    useQueueSocket: true // or false based on your backend version (false: 1.5 or true or false: 1.75)
)

// Initialize SDK instance
let sdk = ECVSdk(config: config)

Configuration Options

The ECVSdkConfiguration class supports various configuration options:

let config = ECVSdkConfiguration(
    name: "Environment_Name",
    serviceUrl: "YOUR_SERVICE_URL",
    useQueueSocket: true,
    webrtcUrl: "YOUR_WEBRTC_URL", // Optional, default: serviceUrl
    signalingUrl: "YOUR_SIGNALING_URL", // Optional, default: serviceUrl
    waitForRoomIntervalDelay: Int, // Optional ( For 1.5 only ), default: 3000
    waitForRoomIntervalEndpoint: String // Optional ( For 1.5 only ), default: "serviceUrl + API.waitForRoomInterval + "?rtcId=""
)

Extra Configs

Logger.setLevel(logLevel: .debug) // .debug To enable debugging everything in SDK (.debug, .info, .warn, .error) // default: .info

Creating and Managing Calls

Creating a Call

// Create and start the video call
let call = await sdk.createVideoCall() 

If you already have an rtcId, you can provide it to the createVideoCall function, otherwise it will be generated from the backend automatically (default)

let call = await sdk.createVideoCall(rtcId: "your_rtcId")

VideoCall Events

Now before we start the call we can add event listener to the call

sdk.modules.onCallEvent.append { (videoCall: VideoCall, newEvent: VideoCallEvent, lastEvent: VideoCallEvent) in
    if(videoCall.rtcId != call.rtcId){
        return // Making sure we only catch the events related to the current call. // comment this code to catch all calls' events
    }

    if(newEvent.type == .AgentConnected) {
        Logger.info("From sdk.modules.onCallEvent: \(newEvent.type)")
    }
    else if(newEvent.type == .Error){
        Logger.error("From sdk.modules.onCallEvent: \(newEvent.detail ?? "")")
    }
    else {
        Logger.info("From sdk.modules.onCallEvent: \(newEvent)")
    }
}

VideoCall Parameters

To start the call, we need to prepare DialCallParameters object

let dialCallParameters = DialCallParameters(
    callerName: "Caller_Name",      // Optional but should be provided, otherwise a random name will be generated
    attributes: [String: String],   // Optional, Attach data for the call
    queue: String?,                 // Optional, Queue name, if not provided, will use system's default queue
    
    // Advanced Optional Params
    acdAttributes: [String: String],
    customPayload: [String: String],
    additionalHeaders: [String: String],
)

Example:

let dialCallParameters = DialCallParameters(
    callerName: "John Doe",
    attributes: [
        "department": "support",
        "priority": "high"
    ],
    queue: "TechSupport",
)

Starting the VideoCall

If we want to start a VideoCall, we use call.start

await call.start(dialCallParameters: dialCallParameters)

Wait for an Agent to connect (inQueue)

There are two simple ways to wait for an agent to connect

1- (1.5 and 1.75+) Using VideoCall events we already implemented above if(newEvent.type == .AgentConnected)

2- (1.75+ Only) Using awaited promisified task:

let isAgentConnected = await call.agentConnected?.value
Logger.info("isAgentConnected: \(String(describing: isAgentConnected))")

if(isAgentConnected == true) {
    // Openning the call in a saperate web browser maybe? // useful for Development
    if let urlString = call.getUrl(), let url = URL(string: urlString) {
        UIApplication.shared.open(url, options: [:], completionHandler: nil)
    }
    else {
        Logger.error("Failed to open URL: invalid URL string")
    }
}
else {
    Logger.warn("Agent not connected!")
}

Connect the VideoCall

1- Using the videoCall.connect()

In your CallScreen.swift

func setup() {
  Task {
      guard let rtcId = self.rtcId else {
          self.callError = "RtcId not initialized"
          Logger.error("Setup failed: RtcId is nil")
          return
      }

      if let videoCall = appState.sdk?.getVideoCall(rtcId: rtcId){
          self.videoCall = videoCall
      }
      else {
          self.videoCall = await appState.sdk?.createVideoCall(rtcId: rtcId)
      }
      
      // Handle call events
      let ECVModules = appState.sdk?.modules
      ECVModules?.onCallEvent.append { (videoCall: VideoCall, newEvent: VideoCallEvent, lastEvent: VideoCallEvent) in
          if(self.videoCall?.rtcId != videoCall.rtcId){
              return // Making sure we only catch the events related to the current call. // comment this line to catch all calls' events
          }
          
          if(newEvent.type == .CallEnded){
              ECVModules?.onCallEvent = [] // reset events to prevent overflow of events
              path.append(NavigationRoute.mainScreen)
          }
      }

      guard let webRtcConnection = self.videoCall?.connect() else {
          self.callError = "WebRtcConnection failed to connect"
          Logger.error("Setup failed: WebRtcConnection is nil")
          return
      }
      self.webRtcConnection = webRtcConnection

      Logger.debug("Instantiating and assigning renderers...")
      let local = Renderer()
      let remote = Renderer()

      webRtcConnection.localVideoRenderer = local
      webRtcConnection.remoteVideoRenderer = remote

      self.localRenderer = local
      self.remoteRenderer = remote

      Logger.info("Starting WebRTC room...")
      await webRtcConnection.startRoom()
      Logger.info("Call setup complete.")
  }
}

2- Or the caller can join the video call simply using web browser (not recommended / useful for dev)

if let urlString = call.getUrl(), let url = URL(string: urlString) {
    UIApplication.shared.open(url, options: [:], completionHandler: nil)
}
else {
    Logger.error("Failed to open URL: invalid URL string")
}

Video Call Interface

Setting Up Video Views

import Foundation
import SwiftUI
import Combine
import ECV175_iOS_SDK
import WebRTC

struct CallScreen: View {
    let rtcId: String?
    @EnvironmentObject var appState: AppState

    @Binding var path: NavigationPath

    @State private var videoCall: VideoCall?
    @State private var webRtcConnection: WebRtcConnection?

    @State private var localRenderer: Renderer?
    @State private var remoteRenderer: Renderer?

    let localStreamWidth: CGFloat = 80
    let localStreamHeight: CGFloat = 120
    let margin: CGFloat = 10
    let pipBottomPadding: CGFloat = 70
    
    var body: some View {
        ZStack {
            Color.black.ignoresSafeArea()

            WebRtcVideoView(renderer: remoteRenderer).ignoresSafeArea()

            WebRtcVideoView(renderer: localRenderer)
                .frame(width: localStreamWidth, height: localStreamHeight)
                .cornerRadius(8)
                .overlay(
                    RoundedRectangle(cornerRadius: 8)
                        .stroke(Color.white.opacity(0.5), lineWidth: 1)
                )
                .padding(.trailing, margin)
                .padding(.bottom, margin + pipBottomPadding)

            // ... Call Buttons
        }
        .navigationBarHidden(true)
        .statusBar(hidden: true)
        .onAppear(perform: setup)
        .onDisappear {
            hangup(by: "onDisappear")
        }
    }

    // MARK: - Video Renderer SwiftUI Wrapper

    struct WebRtcVideoView: UIViewRepresentable {
        let renderer: (any RTCVideoRenderer)?

        func makeUIView(context: Context) -> UIView {
            if let renderer = renderer as? Renderer {
                return renderer.view
            } else if let renderer = renderer as? Renderer {
                return renderer.view
            } else {
                return UIView()
            }
        }

        func updateUIView(_ uiView: UIView, context: Context) {}
    }

    // MARK: - Custom Renderer Classes

    class Renderer: NSObject, RTCVideoRenderer {
        let view: RTCMTLVideoView

        override init() {
            self.view = RTCMTLVideoView()
            self.view.videoContentMode = .scaleAspectFill
            super.init()
            Logger.debug("Renderer created")
        }

        deinit { Logger.debug("Renderer deallocated") }

        func setSize(_ size: CGSize) {
            view.setSize(size)
        }

        func renderFrame(_ frame: RTCVideoFrame?) {
            view.renderFrame(frame)
        }
    }

    func hangup(by: String = "HangUpButton") {
        Logger.debug("Hangup requested by: \(by)")

        videoCall?.hangup()

        videoCall = nil
        webRtcConnection = nil
        localRenderer = nil
        remoteRenderer = nil
    }

    // func setup(){
    // ... paste it here
    //}
}

Call Controls

// Mute/Unmute Audio
webRtcConnection.setAudioEnabled(state: false) // Mute
webRtcConnection.setAudioEnabled(state: true)  // Unmute

// Enable/Disable Video
webRtcConnection.setVideoEnabled(state: false) // Disable video
webRtcConnection.setVideoEnabled(state: true)  // Enable video

// Switch Camera
try await webRtcConnection.switchCamera()

// Enable/Disable Flashlight
webRtcConnection.setFlashlightEnabled(state: true)
webRtcConnection.setFlashlightEnabled(state: false)

// End Call
videoCall.hangup()

Video Call Event Handling

When an event gets fired in sdk.modules.onCallEvent, the newEvent is VideoCallEvent and newEvent.type is VideoCallEventType

sdk.modules.onCallEvent.append { (videoCall: VideoCall, newEvent: VideoCallEvent, lastEvent: VideoCallEvent) in
    if(videoCall.rtcId != call.rtcId){
        return // Making sure we only catch the events related to the current call. // comment this code to catch all calls' events
    }

    if(newEvent.type == .DialSuccess){
        Logger.debug("From sdk.modules.onCallEvent: \(newEvent.detail ?? "")")
    }
    else if(newEvent.type == .CallEnded){
        // handle it
    }
    //else if(){

    //}
}

each type is self explanatory:

public enum VideoCallEventType {
    case None
    case Init
    case GotRtcId
    case DialSuccess
    case Error
    case OnQueue
    case AgentConnected
    case CallEnded
    case SignalingConnected
    
    case GotLocalStream
    case GotRemoteStream
    
    case JoinedRoom
    case SignalingRegistered
    case RtcPeerConnectionCreated
    
    case GotOffer
    case SentOffer
    case GotAnswer
    case SentAnswer
    
    case AudioMuted
    case AudioUnmuted
    case VideoMuted
    case VideoUnmuted
    
    case RemoteAudioMuted
    case RemoteAudioUnmuted
    case RemoteVideoMuted
    case RemoteVideoUnmuted
    
    case StartHold
    case EndHold
    
    case TakePhotoOn
    case TakePhotoOff
    
    case WebRtcOnDataChannel
    case TextChannelConnected
    case TextChannelMessage
    case ConnectionTimeoutStart
    case ConnectionTimeoutEnd
    case WebRtcConnected
    case WebRtcRenegotiationNeeded

    case WebRtcDisconnected
    case WebRtcFailed
    case Hangup

    case FlashOn
    case FlashOff
    
    case TransferPending
    case TransferCancelled
    case TransferCompleted
}

Error Handling

To handle errors more precisely, we can check videoCall.lastError when an error happens under .onCallEvent

sdk.modules.onCallEvent.append { (videoCall: VideoCall, newEvent: VideoCallEvent, lastEvent: VideoCallEvent) in
    if(videoCall.rtcId != call.rtcId){
        return // Making sure we only catch the events related to the current call. // comment this code to catch all calls' events
    }

    if(newEvent.type == .Error){
        Logger.error("From sdk.modules.onCallEvent: \(newEvent.detail ?? "")")

        Logger.error(videoCall.lastError)
    }
}

videoCall.lastError's type is ErrorObject and inside it there are:

public class ErrorObject {
    public var name: ErrorName
    public var message: String
    
    public init(name: ErrorName = ErrorName.NO_ERROR, message: String = "No error.") {
        self.name = name
        self.message = message
    }
}

public enum ErrorName {
    case NO_ERROR
    case SERVICE_URL_REQUIRED
    case CALL_NOT_INITIALIZED
    case CALL_ALREADY_DIALED
    case QUEUE_SOCKET_CLOSED
    case ERROR_DIALING
    case CALL_NOT_DIALED
    case ERROR_WAITING_FOR_ROOM
    case NO_ICE_SERVERS_FOUND
    case HANGUP_FAILED
}

So we can basically check for a specific error:

sdk.modules.onCallEvent.append { (videoCall: VideoCall, newEvent: VideoCallEvent, lastEvent: VideoCallEvent) in
    if(videoCall.rtcId != call.rtcId){
        return // Making sure we only catch the events related to the current call. // comment this code to catch all calls' events
    }

    if(newEvent.type == .Error){
        Logger.error("From sdk.modules.onCallEvent: \(newEvent.detail ?? "")")
        Logger.error(videoCall.lastError)

        switch videoCall.lastError.name {
            case .SERVICE_URL_REQUIRED
                break
            case .CALL_NOT_DIALED
                break
            case .NO_ICE_SERVERS_FOUND
                break
            // etc..
        }
    }
}

Permission Handling

// Request camera and microphone permissions
AVCaptureDevice.requestAccess(for: .video) { granted in
    if granted {
        // Camera permission granted
    } else {
        // Camera permission denied
    }
}

AVCaptureDevice.requestAccess(for: .audio) { granted in
    if granted {
        // Microphone permission granted
    } else {
        // Microphone permission denied
    }
}

Best Practices

weak var call: VideoCall?
weak var webRtcConnection: WebRtcConnection?

Configuration Guide

This document details the configuration options available in the ECV Video Call iOS SDK.

SDK Configuration

Basic Configuration

The ECVSdkConfiguration class is used to configure the video call instance:

let config = ECVSdkConfiguration(
    name: "Environment_Name" 
    serviceUrl: "YOUR_SERVICE_URL",
)

Required Parameters

Optional Parameters

Example Usages:

let configV175 = ECVSdkConfiguration(
    name: "Some ECV 1.75 App" 
    serviceUrl: "https://prod-v175.ecv.example.com"
)

let configV15 = ECVSdkConfiguration(
    name: "Some ECV 1.5 App" 
    serviceUrl: "https://prod-v15.ecv.example.com",
    useQueueSocket: false
)

let configSeparateV15 = ECVSdkConfiguration(
    name: "Some custom ECV 1.5 App",
    serviceUrl: "https://api.example.com",
    webrtcUrl: "https://webrtc-v15.example.com", // Separate endpoint for /join
    signalingUrl: "https://websocket-v15.example.com", // Separate WebSocket server (if applicable for v1.5 signaling)
    useQueueSocket: false, // Required for v1.5
    waitForRoomIntervalDelay: 3000, // Poll every 5 seconds
    waitForRoomIntervalEndpoint: "/custom/pollstatus?callid=" // Custom polling endpoint
)

Call Configuration

Basic Call Configuration

The DialCallParameters class is used to configure individual calls:

let dialCallParameters = DialCallParameters() // No required parameters

Optional DialCallParameters Parameters

Example Usages:

let dialCallParameters = DialCallParameters(
    callerName: "Jane Doe",
    attributes: [
        "accountNumber" to "ACC9876",
        "lastInteraction" to "2023-10-26"
    ],
    queue: "SupportQueue",
    additionalHeaders: ["X-Auth-Token": "user_session_token"]
)

await call.start(dialCallParameters: dialCallParameters)

WebRTC Connection Parameters

These parameters are optionally provided when you call videoCall.connect() and fine-tune the WebRTC peer connection behavior. Most parameters have sensible defaults.

Example Usage:

let customConnectParams = ConnectParameters(
    videoWidth: 1280,
    videoHeight: 720,
    videoCodec: "H264",
    additionalHeaders: ["X-WebRTC-Auth": "webrtc_token"]
)

// Get the WebRtcConnection using the custom parameters
let webRtcConnection = videoCall.connect(parameters: customConnectParams)
webRtcConnection.startRoom()

DataChannelConfig

DataChannelConfig is a configuration model used to initialize a data channel in a peer-to-peer communication environment.

Properties

Initializer

init(
    enabled: Bool,
    label: String,
    id: Int = -1,
    negotiated: Bool = false,
    protocol: String = "",
    ordered: Bool = true,
    maxRetransmits: Int = -1,
    maxRetransmitTimeMs: Int = -1
)

Demo Application Guide

Overview

The ECV175_iOS_DEMO application serves as a practical example of how to integrate and utilize the ECV Video Call SDK in an iOS application. This guide will walk you through the application's architecture, key components, and how to use it effectively.

Application Architecture

Core Components

Key Features

Getting Started

Prerequisites

Setup Process

Application Flow

Code Structure

Key Files

Best Practices

Troubleshooting

SDK Integration and Technical Details

Core Configuration and Build System

Screen-by-Screen SDK Integration

SDK Version Compatibility

Event Handling System

Best Practices for SDK Integration

Conclusion

The ECV175_iOS_DEMO application provides a solid foundation for implementing video call functionality using the ECV Video Call SDK. By following this guide and understanding the application's architecture, you can effectively integrate video calling features into your own iOS applications.

For more detailed information about specific features or implementation details, please refer to the SDK documentation and API reference.

Events and State Management

Introduction

The ECV iOS SDK operates asynchronously. It uses an event-driven architecture to communicate status changes, errors, and other important occurrences to your application. Understanding these events is crucial for building a responsive and robust UI.

This guide details the structure of SDK events, lists the key event types, and mentions relevant state properties.

Subscribing to Events

You listen for events on a sdk.modules.onCallEvent instance:

sdk.modules.onCallEvent.append { (videoCall: VideoCall, newEvent: VideoCallEvent, lastEvent: VideoCallEvent) in
    if(videoCall.rtcId != call?.rtcId){
        return // Making sure we only catch the events related to the current call. // comment this code to catch all calls' events
    }
    
    if(newEvent.type == .Error){
        // Handle Error event
    }
    else if(newEvent.type == .AgentConnected) {
        // Handle AgentConnected event
    }
    else {
        print("From ECVModules?.onCallEvent: \(newEvent)")
    }
}

Refer to the "Video Call Event Handling" section in Usage Guide for detailed code examples of both subscription methods.

Event Structure (VideoCallEvent)

Key Fields:

Event Type Reference (VideoCallEventType)

Here's a breakdown of common event types, grouped by the typical phase of a call:

Phase 1: Initialization & Dialing

Phase 2: Queue & Agent Connection

Phase 3: WebRTC Connection Establishment

These events are typically handled internally by WebRtcConnection but can be observed for debugging or advanced use cases. The key event signaling success is WebRtcConnected.

Phase 4: Active Call & Media

Phase 5: Call Termination

State Properties

While events signal changes, you can also check some current state properties:

It's generally best practice to react to events to update your UI state rather than constantly polling these properties. Use the properties for initial state checks or decisions where needed (e.g., checking AgentConnected before calling connect()).

Customization Guide

Introduction

The provided Demo Application (ECV175_iOS_DEMO) showcases the core functionalities of the ECV SDK. However, your production application will undoubtedly have different UI/UX requirements, configuration methods, and data needs. This guide provides advice on adapting the SDK and demo concepts to your specific application.

1. UI Implementation

The demo uses SwiftUI, but the SDK itself is UI-agnostic. You can integrate it into applications built with:

Key Considerations for Your UI:

2. Configuration (ECVSdkConfiguration)

The demo's EnvironmentsScreen.swift is designed for easily testing different backend environments. You will likely not need this screen in your production application.

Production Configuration Strategies:

Important: Ensure the useQueueSocket parameter in your chosen ECVSdkConfiguration matches the capabilities of your target ECV backend (false for v1.5, true recommended for v1.75+).

3. Call Data (DialCallParameters)

The demo uses selectableQueues in Build.swift to dynamically add dropdowns (queue selection) for call data based on the selected environment. This is specific to the demo's multi-environment setup.

In your application, you should populate DialCallParameters with relevant contextual data just before calling videoCall.start().

Example:

// User profile data
val userId = "user123"
val accountType = "Premium"
val intent = "Billing Inquiry"

// Target queue/skill
val targetQueue = "BillingSupport"

// Get SDK instance and create call
val videoCall = sdkInstance.createVideoCall()
// ... wait for GotRtcId ...

// Build parameters with app-specific data
val dialParams = DialCallParameters(
    callerName = "User $userId", // Or actual user name
    attributes = [
        "userId": userId,
        "accountType": accountType,
        "callIntent": intent
    ],
    acdAttributes = [
        "skill": "Billing" // Example ACD attribute
    ],
    queue = targetQueue, // Explicitly set the target queue
    additionalHeaders = ["Authorization": "Bearer \(getUserAuthToken())"] // Example auth
)

// Start the call
videoCall.start(dialParams)

// Navigate to Queue/Waiting screen

4. Event Handling Logic

While the demo shows how to subscribe to events, what you do in response is application-specific. Ensure your implementation correctly handles key events for:

5. Advanced Customization (Optional)

6. Permissions

Always follow iOS's best practices for requesting permissions:

7. Additional Modules

7.1 Call Transfer v1.0.18.45+

This module allows an active, ongoing call to be directed to a different agent/queue. The lifecycle of a transferred call is as follows:

• The source call is dialed (call creation).

• The source call waits in the queue.

• The source call is connected.

• The agent initiates the transfer.

• The transfer can be to a queue or directly to a different agent.

• A direct transfer to an agent can be canceled or rejected by the agent.

• A "TransferPending" event is received via ECVModules?.onCallEvent.

  • When this event is received, a message such as "Please wait, your call will be transferred shortly" can be displayed to the user in the interface.

  • At any point after this event, a "TransferCancelled" event may arrive. When the cancel event is received, the displayed warning must be hidden. The call will continue as normal.

• The agent may have placed the call on HOLD before the transfer, so the transfer message must be displayed in front of the HOLD interface.

• When the transfer is complete, a "TransferCompleted" event will be received via ECVModules?.onCallEvent. The newEvent.data?["rtcId"] will contain the new RtcId value assigned to the transferred call.

• The current call view and all associated resources are destroyed.

• The user is sent back to the queue page, this time with the new RtcId.

• The user waits in the queue as if a new call was initiated and is connected via an "AgentConnected" event when an agent is ready.

• Notes: 
  • If transfer is detected in queue screen, a new call must be created, not getting existing one

    • // instead of
      let call = appState.sdk?.getVideoCall(rtcId: rtcId!) // without call transfer feature
      
      // we write this
      let call = isTransferred == true ? await appState.sdk?.createVideoCall(rtcId: rtcId) : appState.sdk?.getVideoCall(rtcId: rtcId!) // with call transfer feature

  • DialExRequest must not be called while waiting in-queue screen, thus, as written in Demo application, the following code must be called instead of await call?.start()

    • if(isTransferred == true){ // Call Transfer, we don't have to dial, just wait in queueSocket
        call?.isDialed = true
        _ = await call?.createQueueSocket()
        return
      }

An implementation example for this scenario is available in the demo application.

7.2 Remote agent flash triggering

This module will allow an agent to turn on/off customer phone's flashlight remotely.

Troubleshooting Guide

This guide provides solutions and debugging steps for common issues encountered while integrating or using the ECV iOS SDK.

Common Issues & Solutions

Build & Dependency Errors

Runtime Crashes

Media Quality Issues

Specific Feature Issues

General Debugging Steps

Contacting Support

When contacting support, please provide: