Callbacks

Overview

Only the simple code, RemonCast and RemonCall, can be used for communication and broadcasting services. Occasionally, UI handling and additional actions are required depending on your needs. Various Callbacks can be used for more detailed development as shown below.

Broadcasting and communication have appropriate events and flows. Knowing this will help you use Callbacks. Please refer to the following for the details.

pageFlow

pageChannel

Basics

onInit(token)

onInit means the SDK is ready to use RemoteMonster's broadcasting and communication infrastructure by successfully connecting to the RemoteMonster server over the Internet. At this time, the authentication information, token, is returned. In many cases, there is no need for its use, and it is used for debugging.

Web

const listener = {
  onInit(token) {
    // Do something
  }
}

Android

remonCast.onInit(() -> {
    // Do something
});

Swift

remonCast.onInit { (token) in
  // Do something
}

Objc

[remonCast onInitWithBlock:^{
    // Do something
}];

onCreate(channelId) - livecast

Only the caster uses this for the broadcasting service. At this time, the broadcast which the caster creates with create() is normally transmitted.

onCreate passes channelId as an argument. This is a unique identifier of this room, where viewers will use this channelId for connection and watch the broadcast.

Web

const listener = {
  onCreate(channelId) {
    // Do something
  }
}

const cast = new Remon({ listener })
cast.createCast()                          // Server generate chid

Android

remonCast.onCreate((channelId) -> {
    // Do something
});

remonCast.create();             // Server generate channelId

Swift

remonCast.onCreate { (channelId) in
  // Do something
}

remonCast.create()               // Server generate chid

Objc

[remonCast onCreateWithBlock:^(NSString * _Nullable chId) {
    // Do something
}];

onJoin() - livecast

Only viewers use this in the broadcasting service. This will be called when a viewer becomes able to watch media after he/she successfully establishes a connection with join().

Web

const listener = {
  onJoin(channelId) {
    // Do something
  }
}

const cast = new Remon({ listener })
cast.joinCast('MY_CHANNEL_ID')                    // 'channelId' is mandatory

Android

remonCast.onJoin(() ->
    // Do something
});

remonCast.join('MY_CHANNEL_ID');             // `channelId` is mandatory

Swift

remonCast.onJoin {
  // Do something
}

remonCast.join('MY_CHANNEL_ID')            // 'channelId' is mandatory

Objc

[remonCast onJoinWithBlock:^(NSString * _Nullable chId) {
    // Do something
}];

[remonCast joinWithChId:@"MY_CHANNEL_ID" AndConfig:nil];

onConnect(channelId) - communication

This is used only for communication. This often behaves differently in the following cases: the Caller who requests a call by actually creating a channel, and the Callee that responds to the request by accessing the created channel. In this case, the developer must manage the caller-callee status.

The caller uses connect() to create a new channel and wait for the other party to enter.

The Callee will connect to the channel that has already been created by connect(). At this time, the channelId of the created channel is required. If the connection is successful, onConnect will be generated. It is recommended that the Callee use onComplete, which occurs immediately.

Web

const listener = {
  onConnect(channelId) {
    if (isCaller) {
      // Do something
    }
  }
}

const call = new Remon({ listener })
call.connectCall()
// Or
call.connectCall('MY_CHANNEL_ID')

Android

remonCall.onConnect((channelId) -> {
    // Do something
});

remonCall.connect();
// Or
remonCall.connect("MY_CHANNEL_ID");

Swift

remonCall.onConnect { (channelId) in
     // Do something
}

remonCast.connect()
// Or
remonCast.connect("MY_CHANNEL_ID")

Objc

[remonCall onConnectWithBlock:^(NSString * _Nullable chId) {
    // Do something
}];

[remonCall connect:@"MY_CHANNEL_ID" :nil];

onComplete() - communication

This is used for communication only. This will be called when media transfer becomes possible after the connection between the Caller and the Callee is successfully established.

Web

const listener = {
  onComplete() {
    // Do something
  }
}

Android

remonCall.onComplete(() -> {
    // Do something
});

Swift

remonCall.onComplte {
    // Do something
}

Objc

[remonCall onCompleteWithBlock:^{
    // Do something

onClose()

This is called when the user explicitly calls the close() function or when the other party calls the close() function. This is also called to terminate the connection when it is difficult to keep the connection due to a network error. The resources used by Remon have already been released.

Web

const listener = {
  onClose() {
    // Do something
  }
}

const remon = new Remon({ listener })
remon.close()

Android

remonCast.onClose(() -> {
    // Do something
});

remonCast.close();

Swift

remonCall.onClose {
    // Do something
}

[remonCall closeRemon:YES];

Objc

[remonCast onCloseWithBlock:^{
    // Do something
}];

onError(error)

This is called when an error occurs while Remon is running.

Web

const listener = {
  onError(error) {
    // Do something
  }
}

Android

remonCast.onError((error) -> {
    // Do something
});

Swift

remonCast.onError { (error) in
    // Do something
}

Objc

Sorry next version supported

Please refer to the following for the details.

pageError Code

Advanced

onStateChange(state)

The method is used to handle all state changes in the following process: creating the first Remon object, creating a room, connecting to the room successfully, terminating the broadcasting and communication service. The RemonStateEnum object tells the state changes. This is not generally used and is useful for debugging.

RemonState has the following states:

Values	Description	Remarks
INIT	Initiate
WAIT	Create a Channel
CONNECT	Channel, connect to the room
COMPLETE	Connection complete
FAIL	Failed
CLOSE	End

Web

const listener = {
  onStateChange(state) {
    // Do something
  }
}

Android

N/A

iOS

N/A

onStat(report)

This is used for receiving a report of the communication or broadcasting status. Each report comes in every statInterval interval that you have set when you create remon. Since it shows the media quality according to the network situation, it is useful for guiding the user through the handling of loading a UI.

Web

const listener = {
  onStat(result) {
    // Do something
  }
}

Android

remonCast.onStat((result) -> {
    // Do something
});

Swift

let remonCall = RemonCall()
remoCall.onRemonStatReport{ (result) in 
    let rating = result.getRttRating()
    // Do something
}

Objc

Sorry next version supported

Please refer to the following for the details.

pageRealtime Quality Statistics Report