coretypes.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 <stdint.h>
#include <string>
#include <vector>

#define UNUSED(x) (void)x;


typedef unsigned int uint;

namespace ttv
{
    using UserId = uint32_t;
    using ChannelId = uint32_t;
    using GameId = uint32_t;
    
    // Represents an absolute time in seconds since epoch.
    using Timestamp = uint32_t;
    using Color = uint32_t;
    using BroadcastId = uint32_t;
    

    struct UserInfo
    {
        UserInfo();
        
        bool operator==(const UserInfo& other) const;
        bool operator!=(const UserInfo& other) const;
        
        std::string userName;
        std::string displayName;
        std::string bio;
        std::string logoImageUrl;
        UserId userId;
        Timestamp createdTimestamp;
    };

    enum class BroadcasterType
    {
        Partner,
        Affiliate,
        None,       
        Unknown
    };

    struct ChannelInfo
    {
        ChannelInfo();

        std::string displayName;
        std::string name;
        std::string game;
        std::string description;
        std::string status;
        std::string language;
        std::string broadcasterLanguage;
        std::string logoImageUrl;
        std::string channelUrl;
        std::string videoBannerImageUrl;
        std::string profileBannerImageUrl;

        ChannelId channelId;
        Color profileBannerBackgroundColor; 
        Timestamp createdAtTimestamp;
        Timestamp updatedAtTimestamp;
        uint32_t numFollowers;
        uint32_t numViews;

        BroadcasterType broadcasterType;
        bool mature;
        bool partner;
    };

    struct PreviewImages
    {
        std::string largeUrl;
        std::string mediumUrl;
        std::string smallUrl;
        std::string templateUrl;
    };

    enum class BroadcastPlatform
    {
        WatchParty,
        Premiere,
        Rerun,
        Playlist,
        Mobile,
        Xbox,
        PS4,
        Live,
        Unknown
    };

    enum class StreamType
    {
        WatchParty,
        Premiere,
        Rerun,
        Playlist,
        Live,
        Unknown
    };

    struct StreamInfo
    {
        StreamInfo();

        // channelInfo.broadcasterType will always be None - https://jira.twitch.com/browse/AML-2538
        ChannelInfo channelInfo;    
        PreviewImages previewImages;
        std::vector<std::string> communityIds;
        std::string game;

        double averageFPS;
        uint64_t streamId;
        uint64_t delay;
        uint64_t viewerCount;
        uint32_t videoHeight;
        Timestamp createdAtTimestamp;

        BroadcastPlatform broadcastPlatform;
        StreamType streamType;
        bool isPlaylist;
    };
    
    enum class PubSubState
    {
        Disconnected,
        Connecting,
        Connected,
        Disconnecting
    };
    
    enum class VodStatus
    {
        Recording,
        Recorded,       
        Unknown         
        
    };
    
    enum class VodType
    {
        Highlight,
        Archive,
        Upload,
        Unknown
    };
    
    struct WatchPartyUpdate
    {
        WatchPartyUpdate();
        
        std::string incrementUrl;   
        std::string vodId;          
        std::string title;          
        std::string watchPartyId;   
        VodType broadcastType;      
        bool viewable;              
    };
    
    struct ProfileImage
    {
        std::string url;            
        std::string format;         
        uint32_t width;             
        uint32_t height;            
    };

    class TrackingValue
    {
    public:
        enum class Type
        {
            Null,
            Boolean,
            Integer,
            Double,
            String
        };
        
        TrackingValue();
        TrackingValue(std::nullptr_t value);
        
        TrackingValue(bool value);
        
        TrackingValue(int64_t value);
        TrackingValue(uint32_t value);
        TrackingValue(int value);
        
        TrackingValue(double value);
        
        TrackingValue(const std::string& value);
        TrackingValue(std::string&& value);
        TrackingValue(const char* value);
        
        TrackingValue(const TrackingValue& src);
        TrackingValue(TrackingValue&& src);
        
        ~TrackingValue();
        
        TrackingValue& operator=(const TrackingValue& src);
        TrackingValue& operator=(TrackingValue&& src);
        
        Type GetType() const { return mType; }
        
        bool GetBooleanValue() const;
        int64_t GetIntegerValue() const;
        double GetDoubleValue() const;
        std::string GetStringValue() const;
        
    private:
        union Value
        {
            Value() {}
            ~Value() {}
            
            bool asBool;
            int64_t asInteger;
            double asDouble;
            std::string asString;
        } mValue;
        
        Type mType;
    };
}