/**
* Requests a list of all games matching the given search string. The result will be returned
* asynchronously via OnGameNameListReceived.
*
* @param str Whether or not the request was made
*/
public void requestGameNameList(String str) {
ErrorCode ret = m_Stream.getGameNameList(str);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error in GetGameNameList: %s\n", err));
}
}
public void getArchivingStateCallback(ErrorCode result, ArchivingState state) {
m_ArchivingState = state;
if (ErrorCode.failed(result)) {
// String err = ErrorCode.getString(result);
// reportWarning(String.Format("ArchivingStateDoneCallback got failure: {0}", err));
}
}
public void getUserInfoCallback(ErrorCode result, UserInfo userInfo) {
m_UserInfo = userInfo;
if (ErrorCode.failed(result)) {
String err = ErrorCode.getString(result);
reportError(String.format("UserInfoDoneCallback got failure: %s", err));
}
}
protected boolean checkError(ErrorCode err) {
if (ErrorCode.failed(err)) {
reportError(ErrorCode.getString(err));
return false;
}
return true;
}
/**
* Send a singular action metadata point to Twitch's metadata service.
*
* @param name A specific name for an event meant to be queryable
* @param streamTime Number of milliseconds into the broadcast for when event occurs
* @param humanDescription Long form string to describe the meaning of an event. Maximum length is
* 1000 characters
* @param data A valid JSON object that is the payload of an event. Values in this JSON object
* have to be strings. Maximum of 50 keys are allowed. Maximum length for values are 255
* characters.
* @return True if submitted and no error, false otherwise.
*/
public boolean sendActionMetaData(
String name, long streamTime, String humanDescription, String data) {
ErrorCode ret =
m_Stream.sendActionMetaData(m_AuthToken, name, streamTime, humanDescription, data);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error while sending meta data: %s\n", err));
return false;
}
return true;
}
public void getGameNameListCallback(ErrorCode result, GameInfoList list) {
if (ErrorCode.failed(result)) {
String err = ErrorCode.getString(result);
reportError(String.format("GameNameListCallback got failure: %s", err));
}
try {
if (m_Listener != null) {
m_Listener.onGameNameListReceived(result, list == null ? new GameInfo[0] : list.list);
}
} catch (Exception x) {
reportError(x.toString());
}
}
/**
* Terminates the broadcast.
*
* @return Whether or not successfully stopped
*/
public boolean stopBroadcasting() {
if (!this.getIsBroadcasting()) {
return false;
}
ErrorCode ret = m_Stream.stop(true);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error while stopping the broadcast: %s", err));
return false;
}
setBroadcastState(BroadcastState.Stopping);
return ErrorCode.succeeded(ret);
}
protected void updateStreamInfo() {
long now = System.nanoTime();
long delta = (now - m_LastStreamInfoUpdateTime) / 1000000000;
// only check every so often
if (delta < s_StreamInfoUpdateInterval) {
return;
}
m_LastStreamInfoUpdateTime = now;
ErrorCode ret = m_Stream.getStreamInfo(m_AuthToken, m_UserName);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error in TTV_GetStreamInfo: %s", err));
}
}
/**
* Pauses the current broadcast and displays the default pause screen.
*
* @return Whether or not successfully paused
*/
public boolean pauseBroadcasting() {
if (!this.getIsBroadcasting()) {
return false;
}
ErrorCode ret = m_Stream.pauseVideo();
if (ErrorCode.failed(ret)) {
// not streaming anymore
stopBroadcasting();
String err = ErrorCode.getString(ret);
reportError(String.format("Error pausing stream: %s\n", err));
} else {
setBroadcastState(BroadcastState.Paused);
}
return ErrorCode.succeeded(ret);
}
/**
* Send the ending datapoint of an event that has a beginning and end.
*
* @param name A specific name for an event meant to be queryable
* @param streamTime Number of milliseconds into the broadcast for when event occurs
* @param sequenceId Associates a start and end event together. Use the corresponding sequenceId
* returned in TTV_SendStartSpanMetaData
* @param humanDescription Long form string to describe the meaning of an event. Maximum length is
* 1000 characters
* @param data A valid JSON object that is the payload of an event. Values in this JSON object
* have to be strings. Maximum of 50 keys are allowed. Maximum length for values are 255
* characters.
* @return True if submitted and no error, false otherwise.
*/
public boolean endSpanMetaData(
String name, long streamTime, long sequenceId, String humanDescription, String data) {
if (sequenceId == -1) {
reportError(String.format("Invalid sequence id: %d\n", sequenceId));
return false;
}
ErrorCode ret =
m_Stream.sendEndSpanMetaData(
m_AuthToken, name, streamTime, sequenceId, humanDescription, data);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error in SendStopSpanMetaData: %s\n", err));
return false;
}
return true;
}
/**
* Returns a fully populated VideoParams struct based on the given width, height and frame rate.
* This function is not the advised way to setup VideoParams because it has no information about
* the user's maximum bitrate. Use the other version of GetRecommendedVideoParams instead if
* possible.
*
* @param width The broadcast width
* @param height The broadcast height
* @param frameRate The broadcast frames per second
* @return The VideoParams
*/
public VideoParams getRecommendedVideoParams(int width, int height, int frameRate) {
VideoParams videoParams = new VideoParams();
videoParams.outputWidth = width;
videoParams.outputHeight = height;
videoParams.targetFps = frameRate;
videoParams.pixelFormat = determinePixelFormat();
videoParams.encodingCpuUsage = EncodingCpuUsage.TTV_ECU_HIGH;
videoParams.disableAdaptiveBitrate = false;
videoParams.verticalFlip = false;
// Compute the rest of the fields based on the given parameters
ErrorCode ret = m_Stream.getDefaultParams(videoParams);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error in GetDefaultParams: %s", err));
return null;
}
return videoParams;
}
/**
* Begins broadcast using the given VideoParams.
*
* @param videoParams The video params
* @return Whether or not successfully broadcasting
*/
public boolean startBroadcasting(VideoParams videoParams) {
if (videoParams == null || !this.getIsReadyToBroadcast()) {
return false;
}
m_VideoParams = videoParams.clone();
// Setup the audio parameters
m_AudioParams = new AudioParams();
m_AudioParams.audioEnabled =
m_EnableAudio && getIsAudioSupported(); // // only enable audio if possible
if (!allocateBuffers()) {
m_VideoParams = null;
m_AudioParams = null;
return false;
}
ErrorCode ret =
m_Stream.start(videoParams, m_AudioParams, m_IngestServer, StartFlags.None, true);
if (ErrorCode.failed(ret)) {
cleanupBuffers();
String err = ErrorCode.getString(ret);
reportError(String.format("Error while starting to broadcast: %s", err));
m_VideoParams = null;
m_AudioParams = null;
return false;
}
setBroadcastState(BroadcastState.Starting);
return true;
}
public void setStreamInfoCallback(ErrorCode result) {
if (ErrorCode.failed(result)) {
String err = ErrorCode.getString(result);
reportWarning(String.format("SetStreamInfoCallback got failure: %s", err));
}
}
public void runCommercialCallback(ErrorCode result) {
if (ErrorCode.failed(result)) {
String err = ErrorCode.getString(result);
reportWarning(String.format("RunCommercialCallback got failure: %s", err));
}
}
/**
* Updates the internals of the controller. This should be called at least as frequently as the
* desired broadcast framerate. Asynchronous results will be fired from inside this function.
*/
public void update() {
if (m_Stream == null || !m_SdkInitialized) {
return;
}
ErrorCode ret = m_Stream.pollTasks();
checkError(ret);
// update the ingest tester
if (getIsIngestTesting()) {
m_IngestTester.update();
// all done testing
if (m_IngestTester.getIsDone()) {
m_IngestTester = null;
setBroadcastState(BroadcastState.ReadyToBroadcast);
}
}
switch (m_BroadcastState) {
// Kick off an authentication request
case Authenticated:
{
setBroadcastState(BroadcastState.LoggingIn);
ret = m_Stream.login(m_AuthToken);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error in TTV_Login: %s\n", err));
}
break;
}
// Login
case LoggedIn:
{
setBroadcastState(BroadcastState.FindingIngestServer);
ret = m_Stream.getIngestServers(m_AuthToken);
if (ErrorCode.failed(ret)) {
setBroadcastState(BroadcastState.LoggedIn);
String err = ErrorCode.getString(ret);
reportError(String.format("Error in TTV_GetIngestServers: %s\n", err));
}
break;
}
// Ready to stream
case ReceivedIngestServers:
{
setBroadcastState(BroadcastState.ReadyToBroadcast);
// Kick off requests for the user and stream information that aren't 100% essential to be
// ready before streaming starts
ret = m_Stream.getUserInfo(m_AuthToken);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error in TTV_GetUserInfo: %s\n", err));
}
updateStreamInfo();
ret = m_Stream.getArchivingState(m_AuthToken);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error in TTV_GetArchivingState: %s\n", err));
}
break;
}
// Waiting for the start/stop callback
case Starting:
case Stopping:
{
break;
}
// No action required
case FindingIngestServer:
case Authenticating:
case Initialized:
case Uninitialized:
case IngestTesting:
{
break;
}
case Paused:
case Broadcasting:
{
updateStreamInfo();
break;
}
default:
{
break;
}
}
}
