Exemple #1
0
        static async Task Main(string[] args)
        {
            var client = new DiscordPipeClient(0, 421688819868237824);

            client.Connected += () =>
            {
                Console.WriteLine("Connected.");
                return(Task.CompletedTask);
            };

            client.Disconnected += () =>
            {
                Console.WriteLine("Disconnected.");
                return(Task.CompletedTask);
            };

            client.Errored += async ex =>
            {
                Console.WriteLine(ex);
            };

            client.Ready += async e =>
            {
                Console.WriteLine("Connected as {0}#{1}", e.User.Username, e.User.Discriminator);

                await client.SetActivityAsync(x =>
                {
                    x.State   = "Working On: MyProject.cs";
                    x.Details = "Editing: MyFile.cs";
                    x.Assets  = new DiscordActivityAssets
                    {
                        LargeImage = "file_type_csharp",
                        LargeText  = "C# Source File",
                        SmallImage = "visualstudio_small",
                        SmallText  = "Solution: MySolution"
                    };

                    x.Timestamps = new DiscordActivityTimestamps
                    {
                        StartTime = DateTimeOffset.Now,
                        EndTime   = DateTimeOffset.Now.AddMinutes(15)
                    };

                    x.Secrets = new DiscordActivitySecrets
                    {
                        Join     = Guid.NewGuid().ToString("D"),
                        Match    = Guid.NewGuid().ToString("D"),
                        Spectate = Guid.NewGuid().ToString("D")
                    };
                });
            };

            await client.ConnectAsync();

            while (true)
            {
                await Task.Delay(100);
            }
        }
        async Task HandleReadyAsync(ReadyEventArgs e)
        {
            if (InitialActivity == null)
            {
                InitialActivity = new DiscordActivity
                {
                    Assets = new DiscordActivityAssets
                    {
                        LargeImage = "gitrpc",
                        LargeText  = "roridev",
                        SmallImage = "git",
                        SmallText  = "narcisism, yay!"
                    },
                    State   = "Loading Visual Studio",
                    Details = "Extension"
                };

                if (Configuration.Discord.DisplayTimestamp)
                {
                    InitialActivity.Timestamps = new DiscordActivityTimestamps {
                        StartTime = DateTimeOffset.Now
                    }
                }
                ;
            }

            await Client.SetActivityAsync(InitialActivity);
        }

        async Task HandleDisconnectedAsync()
        {
            await Task.Delay(5000);

            await SetupPipeAsync();
        }

        async Task SetupPipeAsync()
        {
            if (Client != null)
            {
                await Client.DisconnectAsync();

                Client.Ready        -= HandleReadyAsync;
                Client.Disconnected -= HandleDisconnectedAsync;
                Client = null;
            }

            Client = new DiscordPipeClient(Configuration.Discord.PipeInstanceId,
                                           Configuration.Discord.ApplicationId);

            Client.Ready        += HandleReadyAsync;
            Client.Disconnected += HandleDisconnectedAsync;

            await Client.ConnectAsync();
        }

        DateTimeOffset OriginalStartTime = DateTimeOffset.MinValue;

        void HandleWindowActivated(Window window, Window old)
        {
            if (this.OriginalStartTime == DateTimeOffset.MinValue)
            {
                this.OriginalStartTime = DateTimeOffset.Now;
            }

            _ = Task.Run(async() =>
            {
                try
                {
                    var i11n = Configuration.Localization.GetFormatDelegate();

                    if (window?.Project == null && old?.Project == null)
                    {
                        return;
                    }

                    if (window?.Project == null && old?.Project != null)
                    {
                        window = old;
                    }

                    var activity = GetNextActivity(window, i11n);

                    await Client.SetActivityAsync(activity).ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine("\n\nSET ACTIVITY ERROR: {0}\n\n", args: ex);
                }
            });
        }

        DiscordActivity GetNextActivity(Window window, GetStringFormatDelegate i11n)
        {
            var activity = new DiscordActivity {
                Timestamps = new DiscordActivityTimestamps(),
                Assets     = new DiscordActivityAssets()
            };

            var hasProject     = TryGetProjectName(window, out var project);
            var hasFile        = TryGetFileName(window, out var file, out var extension);
            var hasSolution    = TryGetSolutionName(out var solution);
            var hasSolutionDir = TryGetSolutionDirectory(out string solutionDir);

            if (!FLAG_SEARCHGIT && hasSolutionDir)
            {
                gitDirectory   = Utilities.GetGitDirectory(solutionDir);
                FLAG_SEARCHGIT = true;
            }

            if (hasProject && Configuration.Discord.DisplayProject)
            {
                activity.State = i11n("base_working_text", project);
            }

            if (Configuration.Discord.AutoResetTimestamp)
            {
                OriginalStartTime = DateTimeOffset.Now;
            }

            if (Configuration.Discord.DisplayTimestamp)
            {
                activity.Timestamps.StartTime = OriginalStartTime;
            }

            if (hasSolution && Configuration.Discord.DisplaySolution)
            {
                activity.State = i11n("base_solution_text", solution);
            }

            if (gitDirectory == null)
            {
                activity.Assets.SmallImage = "gitrpc";
                activity.Assets.SmallText  = "No git? what a shame.";
            }

            if (gitDirectory != null)
            {
                activity.Assets.SmallImage = "git";
                activity.Assets.SmallText  = GetCurrentBranch(gitDirectory);
            }

            if (hasFile)
            {
                activity.Details = i11n("base_editing_text", file);
                var asset = GetAssetFromFileExtension(extension);
                activity.Assets.LargeImage = asset.Key;
                activity.Assets.LargeText  = GetAssetName(asset, i11n);
            }

            return(activity);
        }