How Reach℠ Works

Reach℠ is a remote support application for IoT devices. By leveraging a mobile device as a bridge between a customer’s IoT device and a support technician, the support technician can directly and securely interact with the customer’s device. Reach℠ runs on both the customer’s mobile app and the support technician’s computer. The support technician’s computer communicates with the customer’s mobile app, and the mobile app communicates with the IoT device via any communication protocol that the device supports (BLE, MQTT, HTTPS, etc.). This enables the support technician to control the device’s software in real-time, allowing them to diagnose and fix any issues with the device.

A customer requests a support session using their mobile app, and calls or chats with a customer support representative to initiate the Reach℠ support session. The support technician provides the customer with a unique pin to type into their mobile app, which acts as a security layer to prevent unauthorized access to the customer’s device.

Once the technician is allowed access, a two-way communication channel is created between the technician and the customer. The technician leverages the Reach℠ communication functionality to get and set information on the device, without the need for customer interaction. The customer can sit back and relax while the technician works, without the typical back-and-forth that is often required to identify the technical details that are affecting the customer’s device. Instead, the technician has access to all of the technical details of the device via the web-to-mobile and mobile-to-device communication channels.

Device Support

Reach℠ can support any device that can accept incoming communications of some kind. Common communication protocols include Bluetooth, Bluetooth Low Energy, and local WiFi, but a mobile app with Reach℠ may be customized for any kind of communication.

Reach℠ does not support devices that are unable to connect to a different device or to the internet. Reach℠ also doesn’t support existing IoT devices that are unable to accept incoming communications of any form (i.e. no HTTP, no MQTT, no BLE, etc.). However, if the existing device has the ability to update its firmware and/or software, it is likely that an update can enable the device to work with Reach℠.

The Reach℠ SDKs are provided in TypeScript/JavaScript, Kotlin, and Swift and can be integrated into your already-existing device interaction code.

Secure

Reach℠ maintains device security by encrypting all network traffic between devices.

Technicians can only gain access to the device via the customer’s express permission in the form of the customer entering in a pin that is unique to the remote support session requested by the customer.

If the customer’s mobile app connects to their device in the form of Bluetooth, this proximity-based security is maintained by Reach℠ because all communication to the device continues to occur over the Bluetooth connection.

Seamless Customer Interaction

Reach℠ is designed to interact seamlessly with a mobile or web app’s UI. UI elements can react to changes in both the device’s connection status and the device’s state via callbacks, which keeps the customer in the loop about what’s happening on their device. Reach℠ supports chat messages that include text, photos, and videos to help the customer and technician diagnose the issue.

Technicians can perform customer support for customers despite language barriers. Once the technician has access to the device, the customer likely does not need to be involved in the process of updating the device. In order to gain access, the customer only needs to enter a pin number into their mobile app; this is often possible despite language barriers, giving the technician access to the information they need.

If the internet connection between the customer support technician and the customer drops, Reach℠ will automatically reconnect the session when an internet connection is restored and the support session will pick up where it left off. All data transfer is paused on disconnect and resumed on reconnect, ensuring that frequent drops due to poor internet connections don’t prevent customers from getting their devices fixed.

The most common customer support requests are for connectivity issues. Reach℠ can sidestep the issue where technicians are unable to connect to the device remotely due to the customer’s device connectivity issues because, rather than connecting to the device, the technician can connect to the customer’s mobile device, which can, in turn, connect to the device over LAN or BLE technology. This provides better remote access to devices for technicians.

Fast Development Time

The Reach℠ SDKs are designed to facilitate fast development times and robust workflows. The SDKs are object-oriented, making the process of events both easy to follow and easy to write, even for asynchronous programming.

Three different asynchronous message protocols ensure that you can use the right tool for the job. Together the message protocols (including fire-and-forget and request-and-response) allow for fine-grained control over communication between the clients. Their object-oriented implementations make it easy to understand how to use the protocol and to choose which communication protocol is a good fit for the application at hand.

Serialization and deserialization of data often consume a large portion of development time for projects that communicate between IoT devices. The SDKs provided by Reach℠ make it straightforward to identify data types that are encoded in bytes, which in turn makes deserialization straightforward. Reach℠ also has built-in functionality for encoding and decoding JSON messages, so any object that can be encoded to and decoded from JSON is supported by Reach℠ with very minimal development efforts.

Battle Tested

Reach℠ is well-tested across different network conditions, including in rural locations with poor internet access. If a connection is dropped, reconnection occurs automatically and the remote support session picks up where it left off.

We use Reach℠ internally, and we work closely with our clients using Reach℠ to ensure the communication between their devices and support technicians is robust.

Given a standard home or work internet connection, Reach℠ can seamlessly send tens of thousands of small messages per second and large messages up to GBs in sizes without interrupting the web and mobile app UIs, ensuring an excellent customer experience.

Code Examples

We provide clients with code examples illustrating the many use-cases of Reach℠. All examples include code for TypeScript/JavaScript, Kotlin, and Swift. The examples cover all SDK features and how to implement them, along with best practices from our extensive experience working with our customers.

Logging and Tracking

A custom logger can be attached to each SDK to support usage tracking, helping you gain insights into how your customers utilize the platform for their remote support needs. Session IDs are provided to allow for insights and tracking on a session-by-session basis, giving you fine-grained information to work from.

An Example

Below is a simple example of using the JavaScript SDK to restart a device and query its temperature.

// Technician (UI interaction)

const CHAT_MESSAGE = 0;
const REBOOT = 1;
const GET_TEMPERATURE = 2;

function onConnect() {
    changeUIConnectionStatus("GREEN");
}

function onDisconnect() {
    changeUIConnectionStatus("RED");
}

function onNotification(notification) {
    switch(notification.category) {
        case CHAT_MESSAGE {
            let message = decode_text(notification.data);
            pushChatMessage(message);
        }
    }
}

function onCommand(command) {
    switch(command.category) {
        case REBOOT {
            pushLogMessage("Device is restarting...");
        }
    }
}

let client = new reachClient.RemoteSupportClient();
client.onConnect.subscribe(onConnect);
client.onDisconnect.subscribe(onDisconnect);
// etc

// Customer's mobile app (device and UI interaction)

const CHAT_MESSAGE = 0;
const REBOOT = 1;
const GET_TEMPERATURE = 2;

function onCommand(command) {
    switch(command.category) {
        case REBOOT {
            device.reboot();
        }
    }
}

function onQueryReceived(query) {
    switch(query.category) {
        case GET_TEMPERATURE {
            let temperature = device.get_temperature();
            query.respond(new TaggedData(data=new Uint8Array(temperature), tag="float"));
        }
    }
}

let client = new reachClient.RemoteSupportClient();
client.onCommand.subscribe(onCommand);
client.onQuery.subscribe(onQueryReceived);
// etc