hacks: try to implement the state thing

microsoft · Nov 6, 2019 · 1950413 · 1950413
1 parent 22dd029
commit 1950413
Show file tree

Hide file tree

Showing 10 changed files with 60 additions and 51 deletions.
diff --git a/src/cascadia/TerminalConnection/AzureConnection-ARM64.cpp b/src/cascadia/TerminalConnection/AzureConnection-ARM64.cpp
@@ -23,11 +23,11 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
     {
         throw hresult_not_implemented();
     }
-    winrt::event_token AzureConnection::TerminalDisconnected(Microsoft::Terminal::TerminalConnection::TerminalDisconnectedEventArgs const& /*handler*/)
+    winrt::event_token AzureConnection::StateChanged(Windows::Foundation::TypedEventHandler<ITerminalConnection, StateChangedEventArgs> const& handler)
     {
         throw hresult_not_implemented();
     }
-    void AzureConnection::TerminalDisconnected(winrt::event_token const& /*token*/)
+    void AzureConnection::StateChanged(winrt::event_token const& token)
     {
         throw hresult_not_implemented();
     }

diff --git a/src/cascadia/TerminalConnection/AzureConnection-ARM64.h b/src/cascadia/TerminalConnection/AzureConnection-ARM64.h
@@ -15,8 +15,8 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
         static bool IsAzureConnectionAvailable();
         winrt::event_token TerminalOutput(Microsoft::Terminal::TerminalConnection::TerminalOutputEventArgs const& handler);
         void TerminalOutput(winrt::event_token const& token);
-        winrt::event_token TerminalDisconnected(Microsoft::Terminal::TerminalConnection::TerminalDisconnectedEventArgs const& handler);
-        void TerminalDisconnected(winrt::event_token const& token);
+        winrt::event_token StateChanged(StateChangedEventArgs const& handler);
+        void StateChanged(winrt::event_token const& token);
         void Start();
         void WriteInput(hstring const& data);
         void Resize(uint32_t rows, uint32_t columns);

diff --git a/src/cascadia/TerminalConnection/AzureConnection.cpp b/src/cascadia/TerminalConnection/AzureConnection.cpp
@@ -64,28 +64,6 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
         _outputHandlers.remove(token);
     }
 
-    // Method description:
-    // - ascribes to the ITerminalConnection interface
-    // - registers a terminal-disconnected event handler
-    // Arguments:
-    // - the handler
-    // Return value:
-    // - the event token for the handler
-    winrt::event_token AzureConnection::TerminalDisconnected(Microsoft::Terminal::TerminalConnection::TerminalDisconnectedEventArgs const& handler)
-    {
-        return _disconnectHandlers.add(handler);
-    }
-
-    // Method description:
-    // - ascribes to the ITerminalConnection interface
-    // - revokes a terminal-disconnected event handler
-    // Arguments:
-    // - the event token for the handler
-    void AzureConnection::TerminalDisconnected(winrt::event_token const& token) noexcept
-    {
-        _disconnectHandlers.remove(token);
-    }
-
     // Method description:
     // - ascribes to the ITerminalConnection interface
     // - creates the output thread (where we will do the authentication and actually connect to Azure)
@@ -102,6 +80,8 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
 
         THROW_LAST_ERROR_IF_NULL(_hOutputThread);
 
+        _StateChangedHandlers(*this, ConnectionState::Connecting);
+
         _connected = true;
     }
 
@@ -260,6 +240,8 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
 
         if (!_closing.exchange(true))
         {
+            _StateChangedHandlers(*this, ConnectionState::Closing);
+
             _canProceed.notify_all();
             if (_state == State::TermConnected)
             {
@@ -271,6 +253,8 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
             // Tear down our output thread
             WaitForSingleObject(_hOutputThread.get(), INFINITE);
             _hOutputThread.reset();
+
+            _StateChangedHandlers(*this, ConnectionState::Closed);
         }
     }
 
@@ -348,6 +332,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
                 // We are connected, continuously read from the websocket until its closed
                 case State::TermConnected:
                 {
+                    _StateChangedHandlers(*this, ConnectionState::Connected);
                     while (true)
                     {
                         // Read from websocket
@@ -363,7 +348,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
                             if (!_closing.load())
                             {
                                 _state = State::NoConnect;
-                                _disconnectHandlers();
+                                _StateChangedHandlers(*this, ConnectionState::Closed);
                                 return S_FALSE;
                             }
                             break;
@@ -383,7 +368,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
                 case State::NoConnect:
                 {
                     _outputHandlers(winrt::to_hstring(internetOrServerIssue));
-                    _disconnectHandlers();
+                    _StateChangedHandlers(*this, ConnectionState::Failed);
                     return E_FAIL;
                 }
                 }

diff --git a/src/cascadia/TerminalConnection/AzureConnection.h b/src/cascadia/TerminalConnection/AzureConnection.h
@@ -11,6 +11,8 @@
 #include <mutex>
 #include <condition_variable>
 
+#include "../cascadia/inc/cppwinrt_utils.h"
+
 namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
 {
     struct AzureConnection : AzureConnectionT<AzureConnection>
@@ -20,16 +22,15 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
 
         winrt::event_token TerminalOutput(TerminalConnection::TerminalOutputEventArgs const& handler);
         void TerminalOutput(winrt::event_token const& token) noexcept;
-        winrt::event_token TerminalDisconnected(TerminalConnection::TerminalDisconnectedEventArgs const& handler);
-        void TerminalDisconnected(winrt::event_token const& token) noexcept;
         void Start();
         void WriteInput(hstring const& data);
         void Resize(uint32_t rows, uint32_t columns);
         void Close();
 
+        UNTYPED_EVENT(StateChanged, StateChangedEventArgs);
+
     private:
         winrt::event<TerminalConnection::TerminalOutputEventArgs> _outputHandlers;
-        winrt::event<TerminalConnection::TerminalDisconnectedEventArgs> _disconnectHandlers;
 
         uint32_t _initialRows{};
         uint32_t _initialCols{};

diff --git a/src/cascadia/TerminalConnection/ConptyConnection.h b/src/cascadia/TerminalConnection/ConptyConnection.h
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
 #pragma once
@@ -19,15 +19,15 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
 
         winrt::event_token TerminalOutput(TerminalConnection::TerminalOutputEventArgs const& handler);
         void TerminalOutput(winrt::event_token const& token) noexcept;
-        winrt::event_token TerminalDisconnected(TerminalConnection::TerminalDisconnectedEventArgs const& handler);
-        void TerminalDisconnected(winrt::event_token const& token) noexcept;
         void Start();
         void WriteInput(hstring const& data);
         void Resize(uint32_t rows, uint32_t columns);
         void Close();
 
         winrt::guid Guid() const noexcept;
 
+        UNTYPED_EVENT(StateChanged, StateChangedEventArgs);
+
     private:
         HRESULT _LaunchAttachedClient() noexcept;
         void _ClientTerminated() noexcept;

diff --git a/src/cascadia/TerminalConnection/EchoConnection.cpp b/src/cascadia/TerminalConnection/EchoConnection.cpp
@@ -23,17 +23,6 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
         _outputHandlers.remove(token);
     }
 
-    winrt::event_token EchoConnection::TerminalDisconnected(TerminalConnection::TerminalDisconnectedEventArgs const& handler)
-    {
-        handler;
-        throw hresult_not_implemented();
-    }
-
-    void EchoConnection::TerminalDisconnected(winrt::event_token const& token) noexcept
-    {
-        token;
-    }
-
     void EchoConnection::Start()
     {
     }

diff --git a/src/cascadia/TerminalConnection/EchoConnection.h b/src/cascadia/TerminalConnection/EchoConnection.h
@@ -5,6 +5,8 @@
 
 #include "EchoConnection.g.h"
 
+#include "../cascadia/inc/cppwinrt_utils.h"
+
 namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
 {
     struct EchoConnection : EchoConnectionT<EchoConnection>
@@ -13,13 +15,13 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
 
         winrt::event_token TerminalOutput(TerminalConnection::TerminalOutputEventArgs const& handler);
         void TerminalOutput(winrt::event_token const& token) noexcept;
-        winrt::event_token TerminalDisconnected(TerminalConnection::TerminalDisconnectedEventArgs const& handler);
-        void TerminalDisconnected(winrt::event_token const& token) noexcept;
         void Start();
         void WriteInput(hstring const& data);
         void Resize(uint32_t rows, uint32_t columns);
         void Close();
 
+        UNTYPED_EVENT(StateChanged, StateChangedEventArgs);
+
     private:
         winrt::event<TerminalConnection::TerminalOutputEventArgs> _outputHandlers;
     };

diff --git a/src/cascadia/TerminalConnection/ITerminalConnection.idl b/src/cascadia/TerminalConnection/ITerminalConnection.idl
@@ -3,13 +3,32 @@
 
 namespace Microsoft.Terminal.TerminalConnection
 {
+    enum ConnectionState
+    {
+        NotConnected = 0,
+        Connecting,
+        Connected,
+        Closing,
+        Closed,
+        Failed
+    };
+
     delegate void TerminalOutputEventArgs(String output);
-    delegate void TerminalDisconnectedEventArgs();
+    delegate void StateChangedEventArgs(ITerminalConnection connection, ConnectionState newState);
+
+    /*
+    [default_interface] runtimeclass StateChangedEventArgs
+    {
+        ConnectionState State { get; }
+    }
+    */
 
     interface ITerminalConnection
     {
         event TerminalOutputEventArgs TerminalOutput;
-        event TerminalDisconnectedEventArgs TerminalDisconnected;
+
+        event StateChangedEventArgs StateChanged;
+        //ConnectionState State { get; };
 
         void Start();
         void WriteInput(String data);

diff --git a/src/cascadia/TerminalControl/TermControl.cpp b/src/cascadia/TerminalControl/TermControl.cpp
@@ -148,8 +148,13 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         // DON'T CALL _InitializeTerminal here - wait until the swap chain is loaded to do that.
 
         // Subscribe to the connection's disconnected event and call our connection closed handlers.
-        _connection.TerminalDisconnected([=]() {
-            _connectionClosedHandlers();
+        _connection.StateChanged([=](auto&& /*s*/, auto&& v) {
+            auto ff = wil::str_printf<std::wstring>(L"CONNECTION TRANSITIONED TO STATE %d\n", v);
+            OutputDebugStringW(ff.c_str());
+            if (v == TerminalConnection::ConnectionState::Closed)
+            {
+                _connectionClosedHandlers();
+            }
         });
     }
 

diff --git a/src/cascadia/inc/cppwinrt_utils.h b/src/cascadia/inc/cppwinrt_utils.h
@@ -71,6 +71,14 @@ public:
 private:                                                                                                                                    \
     winrt::event<Windows::Foundation::TypedEventHandler<sender, args>> _##name##Handlers;
 
+#define UNTYPED_EVENT(name, args)                                                            \
+public:                                                                                      \
+    winrt::event_token name(args const& handler) { return _##name##Handlers.add(handler); }  \
+    void name(winrt::event_token const& token) noexcept { _##name##Handlers.remove(token); } \
+                                                                                             \
+private:                                                                                     \
+    winrt::event<args> _##name##Handlers;
+
 // This is a helper macro for both declaring the signature and body of an event
 // which is exposed by one class, but actually handled entirely by one of the
 // class's members. This type of event could be considered "forwarded" or