public static async Task <Channel> GetMyChannel(YouTubeConnection connection)
{
Channel channel = await connection.Channels.GetMyChannel();
Assert.IsNotNull(channel);
Assert.IsNotNull(channel.Id);
return(channel);
}
public void ConnectWithOldOAuthToken()
{
TestWrapper(async(YouTubeConnection connection) =>
{
YouTubeConnection connection2 = await YouTubeConnection.ConnectViaOAuthToken(connection.GetOAuthTokenCopy());
YouTubeConnection connection3 = await YouTubeConnection.ConnectViaOAuthToken(connection2.GetOAuthTokenCopy());
});
}
public void GetAuthorizationCodeURLForOAuth()
{
TestWrapper((YouTubeConnection connection) =>
{
string url = YouTubeConnection.GetAuthorizationCodeURLForOAuthBrowser(UnitTestBase.clientID, UnitTestBase.scopes, YouTubeConnection.DEFAULT_OAUTH_LOCALHOST_URL).Result;
Assert.IsNotNull(url);
return(Task.FromResult(0));
});
}
public static YouTubeConnection GetYouTubeLiveClient()
{
if (UnitTestBase.connection == null)
{
UnitTestBase.connection = YouTubeConnection.ConnectViaLocalhostOAuthBrowser(clientID, clientSecret, scopes).Result;
}
Assert.IsNotNull(UnitTestBase.connection);
return(UnitTestBase.connection);
}
public static void Main(string[] args)
{
Logger.SetLogLevel(LogLevel.Debug);
Logger.LogOccurred += Logger_LogOccurred;
Task.Run(async () =>
{
try
{
System.Console.WriteLine("Initializing connection");
YouTubeConnection connection = await YouTubeConnection.ConnectViaLocalhostOAuthBrowser(clientID, clientSecret, scopes);
if (connection != null)
{
Channel channel = await connection.Channels.GetMyChannel();
//Channel channel = await connection.Channels.GetChannelByID("");
if (channel != null)
{
System.Console.WriteLine("Connection successful. Logged in as: " + channel.Snippet.Title);
LiveBroadcast broadcast = await connection.LiveBroadcasts.GetChannelActiveBroadcast(channel);
System.Console.WriteLine("Connecting chat client!");
ChatClient client = new ChatClient(connection);
client.OnMessagesReceived += Client_OnMessagesReceived;
if (await client.Connect(broadcast))
{
System.Console.WriteLine("Live chat connection successful!");
if (await connection.LiveBroadcasts.GetMyActiveBroadcast() != null)
{
await client.SendMessage("Hello World!");
}
while (true) { }
}
else
{
System.Console.WriteLine("Failed to connect to live chat");
}
}
}
}
catch (Exception ex)
{
System.Console.WriteLine(ex.ToString());
}
});
System.Console.ReadLine();
}
internal static IEnumerator InitGlobalChatHandlers()
{
Twitch = new ChatIntegration <ITwitchIntegration>();
YouTube = new ChatIntegration <IYouTubeIntegration>();
Mixer = new ChatIntegration <IMixerIntegration>();
Global = new ChatIntegration <IGlobalChatIntegration>();
bool initTwitch = false, initYouTube = false, initMixer = false;
// Iterate through all the message handlers that were registered
foreach (var instance in registeredInstances)
{
var instanceType = instance.Value.GetType();
var typeName = instanceType.Name;
// Wait for all the registered handlers to be ready
if (!instance.Value.IsPluginReady)
{
Plugin.Log($"Instance of type {typeName} wasn't ready! Waiting until it is...");
yield return(new WaitUntil(() => instance.Value.IsPluginReady));
Plugin.Log($"Instance of type {typeName} is ready!");
}
bool isGlobalIntegration = typeof(IGlobalChatIntegration).IsAssignableFrom(instanceType);
// Mark the correct services for initialization based on type
if (typeof(ITwitchIntegration).IsAssignableFrom(instanceType) || isGlobalIntegration)
{
initTwitch = true;
}
if (typeof(IYouTubeIntegration).IsAssignableFrom(instanceType) || isGlobalIntegration)
{
initYouTube = true;
}
if (typeof(IMixerIntegration).IsAssignableFrom(instanceType) || isGlobalIntegration)
{
initMixer = true;
}
}
// Initialize the appropriate streaming services
if (initTwitch)
{
TwitchWebSocketClient.Initialize_Internal();
}
if (initYouTube)
{
YouTubeConnection.Initialize_Internal();
}
if (initMixer)
{
MixerClient.Initialize_Internal();
}
}
public void OnApplicationQuit()
{
SceneManager.activeSceneChanged -= SceneManager_activeSceneChanged;
SceneManager.sceneLoaded -= SceneManager_sceneLoaded;
Globals.IsApplicationExiting = true;
// Cancel all running tasks
TaskHelper.CancelAllTasks();
// Shutdown our twitch client if it's initialized
TwitchWebSocketClient.Shutdown();
YouTubeConnection.Stop();
}
internal static IEnumerator CreateGlobalMessageHandlers()
{
// Attempt to initialize message handlers for each of our chat services
TwitchMessageHandler.Instance.InitializeMessageHandlers();
YouTubeMessageHandler.Instance.InitializeMessageHandlers();
GlobalMessageHandler.Instance.InitializeMessageHandlers();
bool initTwitch = false, initYouTube = false;
// Iterate through all the message handlers that were registered
foreach (var instance in GlobalMessageHandler.registeredInstances)
{
var instanceType = instance.Value.GetType();
var typeName = instanceType.Name;
// Wait for all the registered handlers to be ready
if (!instance.Value.ChatCallbacksReady)
{
Plugin.Log($"Instance of type {typeName} wasn't ready! Waiting until it is...");
yield return(new WaitUntil(() => instance.Value.ChatCallbacksReady));
Plugin.Log($"Instance of type {typeName} is ready!");
}
// Mark the correct services for initialization based on type
if (typeof(ITwitchMessageHandler).IsAssignableFrom(instanceType))
{
initTwitch = true;
}
if (typeof(IYouTubeMessageHandler).IsAssignableFrom(instanceType))
{
initYouTube = true;
}
if (typeof(IGlobalMessageHandler).IsAssignableFrom(instanceType))
{
initTwitch = true;
initYouTube = true;
}
}
// Initialize the appropriate streaming services
if (initTwitch)
{
TwitchWebSocketClient.Initialize_Internal();
}
if (initYouTube)
{
YouTubeConnection.Initialize_Internal();
}
}
public void OnApplicationStart()
{
if (Instance != null)
{
return;
}
Instance = this;
ChatConfig = new ChatConfig();
TwitchWebSocketClient.Initialize();
YouTubeConnection.Initialize();
SharedCoroutineStarter.instance.StartCoroutine(DelayedStartup());
}
public static void Main(string[] args)
{
Logger.LogOccurred += Logger_LogOccurred;
Task.Run(async() =>
{
try
{
if (string.IsNullOrEmpty(clientID) || string.IsNullOrEmpty(clientSecret))
{
throw new InvalidOperationException("Client ID and/or Client Secret are not set in the UnitTestBase class");
}
System.Console.WriteLine("Initializing connection");
YouTubeConnection connection = await YouTubeConnection.ConnectViaLocalhostOAuthBrowser(clientID, clientSecret, scopes);
if (connection != null)
{
Channel channel = await connection.Channels.GetMyChannel();
if (channel != null)
{
System.Console.WriteLine("Connection successful. Logged in as: " + channel.Snippet.Title);
System.Console.WriteLine("Connecting chat client!");
ChatClient client = new ChatClient(connection);
client.OnMessagesReceived += Client_OnMessagesReceived;
if (await client.Connect())
{
System.Console.WriteLine("Live chat connection successful!");
while (true)
{
}
}
else
{
System.Console.WriteLine("Failed to connect to live chat");
}
}
}
}
catch (Exception ex)
{
System.Console.WriteLine(ex.ToString());
}
});
System.Console.ReadLine();
}
protected static void TestWrapper(Func <YouTubeConnection, Task> function)
{
if (string.IsNullOrEmpty(clientID) || string.IsNullOrEmpty(clientSecret))
{
throw new InvalidOperationException("Client ID and/or Client Secret are not set in the UnitTestBase class");
}
try
{
YouTubeConnection connection = UnitTestBase.GetYouTubeLiveClient();
function(connection).Wait();
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
public YouTubeBot(YouTubeSettings settings, PokeTradeHub <PK8> hub)
{
Hub = hub;
Settings = settings;
Logger.LogOccurred += Logger_LogOccurred;
try
{
Task.Run(async() =>
{
var connection = await YouTubeConnection.ConnectViaLocalhostOAuthBrowser(Settings.ClientID, Settings.ClientSecret, Scopes.scopes, true);
if (connection != null)
{
channel = await connection.Channels.GetChannelByID(Settings.ChannelID);
if (channel != null)
{
client = new ChatClient(connection);
client.OnMessagesReceived += Client_OnMessagesReceived;
if (await client.Connect())
{
await Task.Delay(-1);
}
else
{
}
}
}
EchoUtil.Forwarders.Add(msg => client.SendMessage(msg));
});
}
catch (Exception ex)
{
LogUtil.LogError(ex.Message, "YouTubeBot");
}
}
/// <summary>
/// Creates an instance of the ChannelsService.
/// </summary>
/// <param name="connection">The YouTube connection to use</param>
public ChannelsService(YouTubeConnection connection) : base(connection)
{
}
/// <summary>
/// Creates an instance of the VideosService.
/// </summary>
/// <param name="connection">The YouTube connection to use</param>
public VideosService(YouTubeConnection connection) : base(connection)
{
}
/// <summary>
/// Creates an instance of the YouTubeServiceBase.
/// </summary>
/// <param name="connection">The YouTube connection to use</param>
/// <param name="baseAddress">The base address to use</param>
public YouTubeServiceBase(YouTubeConnection connection, string baseAddress)
{
Validator.ValidateVariable(connection, "connection");
this.connection = connection;
this.baseAddress = baseAddress;
}
/// <summary>
/// Creates an instance of the CommentsService.
/// </summary>
/// <param name="connection">The YouTube connection to use</param>
public CommentsService(YouTubeConnection connection) : base(connection)
{
}
/// <summary>
/// Creates an instance of the OAuthService.
/// </summary>
/// <param name="connection">The YouTube connection to use</param>
public OAuthService(YouTubeConnection connection) : base(connection, OAuthBaseAddress)
{
}
/// <summary>
/// Creates an instance of the YouTubeServiceBase.
/// </summary>
/// <param name="connection">The YouTube connection to use</param>
public YouTubeServiceBase(YouTubeConnection connection) : this(connection, YouTubeRestAPIBaseAddressFormat)
{
}
/// <summary>
/// Creates an instance of the SubscriptionsService.
/// </summary>
/// <param name="connection">The YouTube connection to use</param>
public SubscriptionsService(YouTubeConnection connection) : base(connection)
{
}
/// <summary>
/// Creates a new instance of the ChatClient class.
/// </summary>
/// <param name="connection">The connection to YouTube</param>
public ChatClient(YouTubeConnection connection) : base(connection)
{
}
public static void Main(string[] args)
{
Logger.LogOccurred += Logger_LogOccurred;
Task.Run(async() =>
{
try
{
if (string.IsNullOrEmpty(clientID) || string.IsNullOrEmpty(clientSecret))
{
throw new InvalidOperationException("Client ID and/or Client Secret are not set in the UnitTestBase class");
}
System.Console.WriteLine("Initializing connection");
YouTubeConnection connection = await YouTubeConnection.ConnectViaLocalhostOAuthBrowser(clientID, clientSecret, scopes);
if (connection != null)
{
Channel channel = await connection.Channels.GetMyChannel();
if (channel != null)
{
System.Console.WriteLine("Connection successful. Logged in as: " + channel.Snippet.Title);
System.Console.WriteLine("Performing video upload...");
var video = new Video();
video.Snippet = new VideoSnippet();
video.Snippet.Title = "Test Video - " + DateTimeOffset.Now.ToString("yyyy-MM-dd-HH-mm");
video.Snippet.Description = "Test Video Description";
video.Snippet.Tags = new string[] { "tag1", "tag2" };
video.Snippet.CategoryId = "22";
video.Status = new VideoStatus();
video.Status.PrivacyStatus = "unlisted"; // or "private" or "public"
bool uploadFailureOccurred = false;
do
{
using (var fileStream = new FileStream("video.mp4", FileMode.Open))
{
var videosInsertRequest = connection.GoogleYouTubeService.Videos.Insert(video, "snippet,status", fileStream, "video/*");
videosInsertRequest.ProgressChanged += (IUploadProgress progress) =>
{
switch (progress.Status)
{
case UploadStatus.Uploading:
System.Console.WriteLine("{0} bytes sent.", progress.BytesSent);
break;
case UploadStatus.Failed:
uploadFailureOccurred = true;
System.Console.WriteLine("An error prevented the upload from completing.\n{0}", progress.Exception);
break;
}
};
videosInsertRequest.ResponseReceived += (Video uploadedVideo) =>
{
video = uploadedVideo;
System.Console.WriteLine("Video id '{0}' was successfully uploaded.", uploadedVideo.Id);
};
if (uploadFailureOccurred)
{
uploadFailureOccurred = false;
await videosInsertRequest.ResumeAsync();
}
else
{
await videosInsertRequest.UploadAsync();
}
}
} while (uploadFailureOccurred);
using (var fileStream = new FileStream("thumbnail.jpg", FileMode.Open))
{
ThumbnailsResource.SetMediaUpload thumbnailSetRequest = connection.GoogleYouTubeService.Thumbnails.Set(video.Id, fileStream, "image/jpeg");
thumbnailSetRequest.ProgressChanged += (IUploadProgress progress) =>
{
switch (progress.Status)
{
case UploadStatus.Uploading:
System.Console.WriteLine("{0} bytes sent.", progress.BytesSent);
break;
case UploadStatus.Failed:
System.Console.WriteLine("An error prevented the upload from completing.\n{0}", progress.Exception);
break;
}
};
thumbnailSetRequest.ResponseReceived += (ThumbnailSetResponse uploadedThumbnail) =>
{
if (uploadedThumbnail.Items.Count > 0)
{
System.Console.WriteLine("Thumbnail was successfully uploaded.");
}
};
await thumbnailSetRequest.UploadAsync();
}
System.Console.WriteLine("Uploads completed!");
}
}
}
catch (Exception ex)
{
System.Console.WriteLine(ex.ToString());
}
});
System.Console.ReadLine();
}
/// <summary>
/// Creates an instance of the LiveChatService.
/// </summary>
/// <param name="connection">The YouTube connection to use</param>
public LiveChatService(YouTubeConnection connection) : base(connection)
{
}
/// <summary>
/// Creates an instance of the SearchService.
/// </summary>
/// <param name="connection">The YouTube connection to use</param>
public SearchService(YouTubeConnection connection) : base(connection)
{
}
/// <summary>
/// Creates an instance of the LiveBroadcastsService.
/// </summary>
/// <param name="connection">The YouTube connection to use</param>
public LiveBroadcastsService(YouTubeConnection connection) : base(connection)
{
}
/// <summary>
/// Creates an instance of the PlaylistsService.
/// </summary>
/// <param name="connection">The YouTube connection to use</param>
public PlaylistsService(YouTubeConnection connection) : base(connection)
{
}