coreapi.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/types/coretypes.h"
#include "twitchsdk/core/types/errortypes.h"
#include "twitchsdk/core/pubsub/pubsubclient.h"
#include "twitchsdk/core/corelistener.h"
#include "twitchsdk/core/eventsource.h"
#include "twitchsdk/core/user/userlistener.h"
#include "twitchsdk/core/module.h"
#include "twitchsdk/core/trackingcontext.h"

#include <memory>

namespace ttv
{
    class IChannelListener;
    class ICoreApiClient;
    class ICoreAPIListener;
    class ChannelRepository;
    class IChannelStatus;
    class CoreAPI;
    class SettingRepository;
    class TaskRunner;
    class User;
    class UserRepository;
    struct CoreAPIInternalData;

    TTV_ErrorCode SetClientId(const std::string& clientId);
    TTV_ErrorCode GetClientId(std::string& clientId);
}


class ttv::ICoreApiClient
{
public:
    ICoreApiClient();

    virtual std::string GetClientName() = 0;

    virtual void GetRequiredOAuthScopes(std::vector<std::string>& scopes);

    virtual void CoreUserLoggedIn(std::shared_ptr<User> user);
    virtual void CoreUserLoggedOut(std::shared_ptr<User> user);
    
    virtual void CoreLocalLanguageChanged(const std::string& language);
};


class ttv::CoreAPI : public ModuleBase
{
public:
    using FetchUserInfoCallback = std::function<void(TTV_ErrorCode ec, const UserInfo& userInfo)>;
    using FetchChannelInfoCallback = std::function<void(TTV_ErrorCode ec, const ChannelInfo& channelInfo)>;
    using FetchStreamInfoCallback = std::function<void(TTV_ErrorCode ec, const StreamInfo& streamInfo)>;
    using LogInCallback = std::function<void(TTV_ErrorCode ec, const UserInfo& userInfo)>;
    using LogOutCallback = std::function<void(TTV_ErrorCode ec)>;
    using UploadProfileImageCallback = std::function<void(TTV_ErrorCode ec, const std::vector<ProfileImage>& images)>;
    
public:
    CoreAPI();
    virtual ~CoreAPI();

    // 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 SetListener(std::shared_ptr<ICoreAPIListener> listener);

    std::shared_ptr<UserRepository> GetUserRepository() const { return mUserRepository; }
    std::shared_ptr<ChannelRepository> GetChannelRepository() const { return mChannelRepository; }
    std::shared_ptr<SettingRepository> GetSettingRepository() const { return mSettingRepository; }
    std::shared_ptr<TrackingContext> GetTrackingContext() const { return mTrackingContext; }
    TTV_ErrorCode GetClientId(std::string& clientId);
    TTV_ErrorCode SetLocalLanguage(const std::string& language);
    TTV_ErrorCode GetLocalLanguage(std::string& language);
    TTV_ErrorCode FetchUserInfoById(UserId userId, FetchUserInfoCallback callback);
    TTV_ErrorCode FetchUserInfoByName(const std::string& userName, FetchUserInfoCallback callback);
    TTV_ErrorCode FetchChannelInfoById(ChannelId channelId, const FetchChannelInfoCallback& callback);
    TTV_ErrorCode FetchChannelInfoByName(const std::string& channelName, const FetchChannelInfoCallback& callback);
    TTV_ErrorCode FetchStreamInfoById(ChannelId channelId, const FetchStreamInfoCallback& callback);
    TTV_ErrorCode FetchStreamInfoByName(const std::string& channelName, const FetchStreamInfoCallback& callback);
    TTV_ErrorCode CreateChannelStatus(UserId userId, ChannelId channelId, const std::shared_ptr<IChannelListener>& listener, std::shared_ptr<IChannelStatus>& result);
    TTV_ErrorCode GetRequiredOAuthScopes(std::vector<std::string>& modules, std::vector<std::string>& scopes);

    TTV_ErrorCode LogIn(const std::string& oauthToken, LogInCallback callback);
    TTV_ErrorCode LogOut(UserId userId, LogOutCallback callback);

    TTV_ErrorCode ConnectPubSub(UserId userId);
    TTV_ErrorCode DisconnectPubSub(UserId userId);

    // Reference counting so that CoreAPI isn't shutdown while other systems are using it
    TTV_ErrorCode RegisterClient(std::shared_ptr<ICoreApiClient> client);
    TTV_ErrorCode UnregisterClient(std::shared_ptr<ICoreApiClient> client);

    TTV_ErrorCode SetGlobalSetting(const std::string& key, const std::string& value);
    TTV_ErrorCode RemoveGlobalSetting(const std::string& key);
    TTV_ErrorCode GetGlobalSetting(const std::string& key, std::string& value);

private:
    class PubSubListener : public PubSubClient::IListener
    {
    public:
        PubSubListener(CoreAPI* api);

        // PubSubClient::Listener implementation
        virtual void OnStateChanged(PubSubClient* source, PubSubState state, TTV_ErrorCode ec) override;

    private:
        CoreAPI* mOwner;
    };

    class UserListener : public IUserListener
    {
    public:
        UserListener(CoreAPI* owner);

        // IUserListener implementation
        virtual void OnUserLogInComplete(User* source, TTV_ErrorCode ec) override;
        virtual void OnUserLogOutComplete(User* source, TTV_ErrorCode ec) override;
        virtual void OnUserInfoFetchComplete(User* source, TTV_ErrorCode ec) override;
        virtual void OnUserAuthenticationIssue(User* source, std::shared_ptr<const OAuthToken> oauthToken, TTV_ErrorCode ec) override;

    private:
        CoreAPI* mOwner;
    };

    // PubSubClient::Listener implementation
    void OnPubSubStateChanged(PubSubClient* source, PubSubState state, TTV_ErrorCode ec);

    // IUserListener implementation
    void OnUserLogInComplete(User* source, TTV_ErrorCode ec);
    void OnUserLogOutComplete(User* source, TTV_ErrorCode ec);
    void OnUserInfoFetchComplete(User* source, TTV_ErrorCode ec);
    void OnUserAuthenticationIssue(User* source, std::shared_ptr<const OAuthToken> oauthToken, TTV_ErrorCode ec);

    // ModuleBase overrides
    virtual bool CheckShutdown() override;
    virtual void CompleteShutdown() override;

    TTV_ErrorCode DisposeChannelStatus(const std::shared_ptr<IChannelStatus>& channelStatus);

    void InitializeAnonymousUser();
    TTV_ErrorCode ValidateOAuthToken(const std::string& oauth, const std::function<void(TTV_ErrorCode ec)>& callback);

    std::shared_ptr<ChannelRepository> mChannelRepository;
    std::shared_ptr<UserRepository> mUserRepository;
    std::shared_ptr<TrackingContext> mTrackingContext;
    std::shared_ptr<UserListener> mUserListener;
    std::shared_ptr<PubSubListener> mPubSubListener;
    std::shared_ptr<TaskRunner> mTaskRunner;
    std::shared_ptr<SettingRepository> mSettingRepository;
    std::shared_ptr<CoreAPIInternalData> mInternalData;

    std::vector<std::shared_ptr<ICoreApiClient>> mApiClients;
    std::string mLocalLanguage;
};