broadcastapi.h

Go to the documentation of this file.

/********************************************************************************************
* Twitch Broadcasting SDK
*
* This software is supplied under the terms of a license agreement with Twitch Interactive, Inc. and
* may not be copied or used except in accordance with the terms of that agreement
* Copyright (c) 2012-2016 Twitch Interactive, Inc.
*********************************************************************************************/

#pragma once

#include "twitchsdk/core/coreapi.h"
#include "twitchsdk/core/module.h"
#include "twitchsdk/broadcast/broadcasttypes.h"

#include <unordered_set>
#include <map>
#include <memory>
#include <atomic>

namespace ttv
{
    class TaskRunner;
    class UserRepository;
    class SettingRepository;

    namespace broadcast
    {
        class BroadcastAPI;
        class BroadcastApiInternalData;
        class IBroadcastAPIListener;
        class IIngestTesterListener;
        class UserBroadcastStateHost;
        class TwitchAPI;
        class Streamer;
        class IVideoEncoder;
        class IAudioEncoder;
        class IAudioCapture;
        class IVideoCapture;
        class IIngestTester;
        class IBandwidthStatListener;
        class IMuxer;
    }
}

class ttv::broadcast::BroadcastAPI : public ttv::ModuleBase
{
public:
    using StartBroadcastCallback = std::function<void(TTV_ErrorCode ec)>;
    using StopBroadcastCallback = std::function<void(TTV_ErrorCode ec)>;
    using FetchIngestListCallback = std::function<void(TTV_ErrorCode ec, std::vector<IngestServer>&& result)>;
    using RunCommercialCallback = std::function<void(TTV_ErrorCode ec)>;
    using SetStreamInfoCallback = std::function<void(TTV_ErrorCode ec)>;

public:
    BroadcastAPI();
    virtual ~BroadcastAPI();

    // IModule implementation
    virtual std::string GetModuleName() const override;
    virtual TTV_ErrorCode Initialize(const InitializeCallback& callback) override;
    virtual TTV_ErrorCode Shutdown(const ShutdownCallback& callback) override;
    virtual TTV_ErrorCode Update() override;

    TTV_ErrorCode SetCoreApi(const std::shared_ptr<CoreAPI>& coreApi);
    TTV_ErrorCode SetListener(const std::shared_ptr<IBroadcastAPIListener>& listener);
    TTV_ErrorCode SetCustomMuxer(const std::shared_ptr<IMuxer>& muxer);
    TTV_ErrorCode SetBroadcasterSoftware(const std::string& str);
    TTV_ErrorCode SetForceArchiveBroadcast(bool forceArchive);
    TTV_ErrorCode SetActiveUser(UserId userId);
    TTV_ErrorCode SetVideoEncoder(const std::shared_ptr<IVideoEncoder>& encoder);
    TTV_ErrorCode SetAudioEncoder(const std::shared_ptr<IAudioEncoder>& encoder);
    TTV_ErrorCode SetVideoCapturer(const std::shared_ptr<IVideoCapture>& capturer);
    TTV_ErrorCode SetAudioCapturer(AudioLayerId layer, const std::shared_ptr<IAudioCapture>& capturer);
    TTV_ErrorCode RemoveAudioCapturer(AudioLayerId layer);
    TTV_ErrorCode SetAudioLayerVolume(AudioLayerId layer, float volume);
    TTV_ErrorCode SetAudioLayerMuted(AudioLayerId layer, bool muted);
    TTV_ErrorCode SetAudioLayerEnabled(AudioLayerId layer, bool enabled);
    TTV_ErrorCode SetVideoParams(const VideoParams& videoParams);
    TTV_ErrorCode GetVideoParams(VideoParams& videoParams);
    TTV_ErrorCode SetOutputPath(const std::wstring& outputPath);
    TTV_ErrorCode SetConnectionType(ConnectionType connectionType);
    TTV_ErrorCode SetSessionId(const std::string& sessionId);
    TTV_ErrorCode AddBandwidthStatListener(const std::shared_ptr<IBandwidthStatListener>& listener);
    TTV_ErrorCode RemoveBandwidthStatListener(const std::shared_ptr<IBandwidthStatListener>& listener);
    TTV_ErrorCode StartBroadcast(StartBroadcastCallback&& callback);
    TTV_ErrorCode StopBroadcast(const std::string& reason, StopBroadcastCallback&& callback);
    TTV_ErrorCode GetCurrentBroadcastTime(uint64_t& broadcastTime);
    TTV_ErrorCode FetchIngestServerList(FetchIngestListCallback&& callback);
    TTV_ErrorCode GetSelectedIngestServer(IngestServer& result);
    TTV_ErrorCode SetSelectedIngestServer(const IngestServer& server);

    TTV_ErrorCode GetBroadcastState(BroadcastState& result) const;

    TTV_ErrorCode RunCommercial(UserId userId, ChannelId channelId, uint32_t timebreakSeconds, RunCommercialCallback&& callback);
    TTV_ErrorCode SetStreamInfo(UserId userId, ChannelId channelId, const std::string& game, const std::string& title, SetStreamInfoCallback&& callback);
    TTV_ErrorCode CreateIngestTester(UserId userId, const std::shared_ptr<IIngestTesterListener>& listener, const uint8_t* testDataBuffer, uint32_t testDataLength, std::shared_ptr<IIngestTester>& result);
    TTV_ErrorCode DisposeIngestTester(const std::shared_ptr<IIngestTester>& ingestTester);
    static void GetRequiredAuthScopes(std::vector<std::string>& scopes);

private:
    class CoreApiClient : public ICoreApiClient
    {
    public:
        CoreApiClient(BroadcastAPI* api);

        // ICoreApiClient implementation
        virtual std::string GetClientName();
        virtual void GetRequiredOAuthScopes(std::vector<std::string>& scopes);
        virtual void CoreUserLoggedIn(std::shared_ptr<User> user);
        virtual void CoreUserLoggedOut(std::shared_ptr<User> user);

    private:
        BroadcastAPI* mApi;
    };

    // ICoreApiClient implementation
    void CoreUserLoggedIn(std::shared_ptr<User> user);
    void CoreUserLoggedOut(std::shared_ptr<User> user);

    // ModuleBase overrides
    virtual bool CheckShutdown() override;
    virtual void CompleteShutdown() override;
    
    std::shared_ptr<Streamer> CreateStreamer(const std::shared_ptr<User>& user);
    std::shared_ptr<TwitchAPI> CreateTwitchAPI(const std::shared_ptr<User>& user);
    TTV_ErrorCode GetStreamer(std::shared_ptr<Streamer>& result);
    TTV_ErrorCode EnsureBroadcastingAndGetStreamer(std::shared_ptr<Streamer>& result);
    TTV_ErrorCode EnsureNotBroadcastingAndGetStreamer(std::shared_ptr<Streamer>& result);

    TTV_ErrorCode BindToUser(const std::shared_ptr<User>& user);

    void SetBroadcastState(TTV_ErrorCode ec, BroadcastState state);

    std::shared_ptr<BroadcastApiInternalData> mInternalData;
    std::shared_ptr<CoreApiClient> mCoreApiClient; 
};