/** * Sets the visible data about the channel of the currently logged in user. * * @param channel The name of the channel. * @param game The name of the game. If the empty string or null then this parameter is ignored. * @param title The title of the channel. If the empty string or null then this parameter is * ignored. * @return Whether or not the request was made */ public boolean setStreamInfo(String channel, String game, String title) { if (!m_LoggedIn) { return false; } if (channel == null || channel == "") { channel = m_UserName; } if (game == null) { game = ""; } if (title == null) { title = ""; } StreamInfoForSetting info = new StreamInfoForSetting(); info.streamTitle = title; info.gameName = game; ErrorCode err = m_Stream.setStreamInfo(m_AuthToken, channel, info); checkError(err); return ErrorCode.succeeded(err); }
/** Initializes the SDK and the controller. */ public boolean initializeTwitch() { if (m_SdkInitialized) { return false; } String dllPath = m_DllPath; if (dllPath == "") { dllPath = "./"; } m_Stream.setStreamCallbacks(this); ErrorCode err = m_Stream.initialize(m_ClientId, VideoEncoder.TTV_VID_ENC_DEFAULT, dllPath); if (!checkError(err)) { m_Stream.setStreamCallbacks(null); return false; } err = m_Stream.setTraceLevel(MessageLevel.TTV_ML_ERROR); if (!checkError(err)) { m_Stream.setStreamCallbacks(null); return false; } if (ErrorCode.succeeded(err)) { m_SdkInitialized = true; setBroadcastState(BroadcastState.Initialized); return true; } return false; }
public ErrorCode submitFrame(FrameBuffer bgraFrame) { if (this.getIsPaused()) { resumeBroadcasting(); } else if (!this.getIsBroadcasting()) { return ErrorCode.TTV_EC_STREAM_NOT_STARTED; } ErrorCode ret = m_Stream.submitVideoFrame(bgraFrame); // if there is a problem when submitting a frame let the client know if (ret != ErrorCode.TTV_EC_SUCCESS) { String err = ErrorCode.getString(ret); if (ErrorCode.succeeded(ret)) { reportWarning(String.format("Warning in SubmitTexturePointer: %s\n", err)); } else { reportError(String.format("Error in SubmitTexturePointer: %s\n", err)); // errors are not recoverable stopBroadcasting(); } if (m_Listener != null) { m_Listener.onframeSubmissionIssue(ret); } } return ret; }
public void stopCallback(ErrorCode ret) { if (ErrorCode.succeeded(ret)) { m_VideoParams = null; m_AudioParams = null; cleanupBuffers(); try { if (m_Listener != null) { m_Listener.onBroadcastStopped(); } } catch (Exception x) { reportError(x.toString()); } if (m_LoggedIn) { setBroadcastState(BroadcastState.ReadyToBroadcast); } else { setBroadcastState(BroadcastState.Initialized); } } else { // there's not really a good state to go into here setBroadcastState(BroadcastState.ReadyToBroadcast); String err = ErrorCode.getString(ret); reportError(String.format("stopCallback got failure: %s", err)); } }
public void onLoginAttemptComplete(ErrorCode result) { if (ErrorCode.succeeded(result)) { if (enableChat) { initChat(); } } }
public void onGameNameListReceived(ErrorCode result, GameInfo[] list) { if (ErrorCode.succeeded(result)) { System.out.println("Game names:"); for (int i = 0; i < list.length; ++i) { System.out.println(" " + list[i].name); } } }
/** * Runs a commercial on the channel. Must be broadcasting. * * @return Whether or not successful */ public boolean runCommercial() { if (!this.getIsBroadcasting()) { return false; } ErrorCode err = m_Stream.runCommercial(m_AuthToken); checkError(err); return ErrorCode.succeeded(err); }
/** * 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); }
public void getStreamInfoCallback(ErrorCode result, StreamInfo streamInfo) { if (ErrorCode.succeeded(result)) { m_StreamInfo = streamInfo; try { if (m_Listener != null) { m_Listener.onStreamInfoUpdated(streamInfo); } } catch (Exception x) { reportError(x.toString()); } } else { // String err = ErrorCode.getString(result); // reportWarning(String.Format("StreamInfoDoneCallback got failure: {0}", 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); }
public void startCallback(ErrorCode ret) { if (ErrorCode.succeeded(ret)) { try { if (m_Listener != null) { m_Listener.onBroadcastStarted(); } } catch (Exception x) { reportError(x.toString()); } setBroadcastState(BroadcastState.Broadcasting); } else { m_VideoParams = null; m_AudioParams = null; setBroadcastState(BroadcastState.ReadyToBroadcast); String err = ErrorCode.getString(ret); reportError(String.format("startCallback got failure: %s", err)); } }
public void loginCallback(ErrorCode result, ChannelInfo channelInfo) { if (ErrorCode.succeeded(result)) { m_ChannelInfo = channelInfo; setBroadcastState(BroadcastState.LoggedIn); m_LoggedIn = true; } else { setBroadcastState(BroadcastState.Initialized); m_LoggedIn = false; String err = ErrorCode.getString(result); reportError(String.format("LoginCallback got failure: %s", err)); } try { if (m_Listener != null) { m_Listener.onLoginAttemptComplete(result); } } catch (Exception x) { reportError(x.toString()); } }
public void requestAuthTokenCallback(ErrorCode result, AuthToken authToken) { if (ErrorCode.succeeded(result)) { // Now that the user is authorized the information can be requested about which server to // stream to m_AuthToken = authToken; setBroadcastState(BroadcastState.Authenticated); } else { m_AuthToken.data = ""; setBroadcastState(BroadcastState.Initialized); String err = ErrorCode.getString(result); reportError(String.format("RequestAuthTokenDoneCallback got failure: %s", err)); } try { if (m_Listener != null) { m_Listener.onAuthTokenRequestComplete(result, authToken); } } catch (Exception x) { reportError(x.toString()); } }
/** * Asynchronously request an authentication key based on the provided username and password. When * the request completes onAuthTokenRequestComplete will be fired. This does not need to be called * every time the user wishes to stream. A valid auth token can be saved locally between sessions * and restored by calling SetAuthToken. If a request for a new auth token is made it will * invalidate the previous valid auth token. If successful, this will proceed to log the user in * and will fire OnLoginAttemptComplete with the result. * * @param username The account username * @param password The account password * @return Whether or not the request was made */ public boolean requestAuthToken(String username, String password) { if (getIsIngestTesting() || !m_SdkInitialized) { return false; } logout(); m_UserName = username; AuthParams authParams = new AuthParams(); authParams.userName = username; authParams.password = password; authParams.clientSecret = m_ClientSecret; ErrorCode err = m_Stream.requestAuthToken(authParams); checkError(err); if (ErrorCode.succeeded(err)) { setBroadcastState(BroadcastState.Authenticating); return true; } return false; }
public void getIngestServersCallback(ErrorCode result, IngestList ingestList) { if (ErrorCode.succeeded(result)) { m_IngestList = ingestList; // assume we're going to use the default ingest server unless overridden by the client m_IngestServer = m_IngestList.getDefaultServer(); setBroadcastState(BroadcastState.ReceivedIngestServers); try { if (m_Listener != null) { m_Listener.onIngestListReceived(ingestList); } } catch (Exception x) { reportError(x.toString()); } } else { String err = ErrorCode.getString(result); reportError(String.format("IngestListCallback got failure: %s", err)); // try again setBroadcastState(BroadcastState.LoggingIn); } }