feat: set keyboard layout functionality

docs/NOW-spec.md

@@ -336,6 +336,7 @@ increment major version; Protocol implementations with different major version a
 | NOW_CAP_SESSION_LOCK<br>0x00000001 | Session lock command support. |
 | NOW_CAP_SESSION_LOGOFF<br>0x00000002 | Session logoff command support. |
 | NOW_CAP_SESSION_MSGBOX<br>0x00000004 | Message box command support. |
+| NOW_CAP_SESSION_SET_KBD_LAYOUT<br>0x00000008 | Set keyboard layout command support. |
 
 **execCapset (4 bytes)**: Remote execution capabilities set.
 
@@ -552,6 +553,7 @@ The NOW_SYSTEM_SHUTDOWN_MSG structure is used to request a system shutdown.NOW_S
 | NOW_SESSION_LOGOFF_MSG_ID<br>0x02 | NOW_SESSION_LOGOFF_MSG |
 | NOW_SESSION_MESSAGE_BOX_MSG_REQ_ID<br>0x03 | NOW_SESSION_MESSAGE_BOX_MSG |
 | NOW_SESSION_MESSAGE_BOX_RSP_MSG_ID<br>0x04 | NOW_SESSION_MESSAGE_RSP_MSG |
+| NOW_SESSION_SWITCH_KBD_LAYOUT_MSG_ID<br>0x05 | NOW_SESSION_SWITCH_KBD_LAYOUT_MSG |
 
 **msgFlags (2 bytes)**: The message flags.
 
@@ -751,6 +753,50 @@ If `status` specifies error, this field should be set to `0`.
 
 **status (variable)**: `NOW_STATUS` structure containing message box response status.
 
+#### NOW_SESSION_SET_KBD_LAYOUT_MSG
+
+The NOW_SESSION_SET_KBD_LAYOUT_MSG message is used to set the keyboard layout for the active
+foreground window. The request is fire-and-forget, invalid layout identifiers are ignored.
+
+<table class="byte-layout">
+    <thead>
+        <tr>
+            <th>0</th><th>1</th><th>2</th><th>3</th><th>4</th><th>5</th><th>6</th><th>7</th>
+            <th>8</th><th>9</th><th>10</th><th>1</th><th>2</th><th>3</th><th>4</th><th>5</th>
+            <th>6</th><th>7</th><th>8</th><th>9</th><th>20</th><th>1</th><th>2</th><th>3</th>
+            <th>4</th><th>5</th><th>6</th><th>7</th><th>8</th><th>9</th><th>30</th><th>1</th>
+        </tr>
+    </thead>
+    <tbody>
+        <tr>
+            <td colspan="32">msgSize</td>
+        </tr>
+        <tr>
+            <td colspan="8">msgClass</td>
+            <td colspan="8">msgType</td>
+            <td colspan="16">msgFlags</td>
+        </tr>
+        <tr>
+            <td colspan="32">kbdLayoutId(variable)</td>
+        </tr>
+    </tbody>
+</table>
+
+**msgSize (4 bytes)**: The message size, excluding the header size (8 bytes).
+
+**msgClass (1 byte)**: The message class (NOW_SESSION_MSG_CLASS_ID).
+
+**msgType (1 byte)**: The message type (NOW_SESSION_SWITCH_KBD_LAYOUT_MSG_ID).
+
+**msgFlags (2 bytes)**: The message flags.
+
+| Flag                                | Meaning                                 |
+|-------------------------------------|-----------------------------------------|
+| NOW_SET_KBD_LAYOUT_FLAG_NEXT<br>0x00000001 | Switches to next keyboard layout. kbdLayoutId field should contain empty string. Conflicts with NOW_SET_KBD_LAYOUT_FLAG_PREV. |
+| NOW_SET_KBD_LAYOUT_FLAG_PREV<br>0x00000002 | Switches to previous keyboard layout. kbdLayoutId field should contain empty string. Conflicts with NOW_SET_KBD_LAYOUT_FLAG_NEXT. |
+
+**kbdLayoutId (variable)**: NOW_STRING structure containing the keyboard layout identifier usually represented as [Windows Keyboard Layout Identifier](https://learn.microsoft.com/en-us/windows-hardware/manufacture/desktop/windows-language-pack-default-values) (HKL).
+
 ### Execution Messages
 
 #### NOW_EXEC_MSG

dotnet/Devolutions.NowClient/src/NowClient.cs

@@ -156,6 +156,43 @@ public async Task SessionMessageBoxNoResponse(MessageBoxParams msgBoxParams)
             await _commandWriter.WriteAsync(command);
         }
 
+        private async Task SessionSetKbdLayoutImpl(NowMsgSessionSetKbdLayout message)
+        {
+            ThrowIfWorkerTerminated();
+
+            if (!Capabilities.SessionCapset.HasFlag(NowCapabilitySession.SetKbdLayout))
+            {
+                ThrowCapabilitiesError("Set keyboard layout");
+            }
+
+            var command = new CommandSessionSetKbdLayout(message);
+            await _commandWriter.WriteAsync(command);
+        }
+
+        /// <summary>
+        /// Set the next keyboard layout for the active foreground window.
+        /// </summary>
+        public async Task SessionSetKbdLayoutNext()
+        {
+            await SessionSetKbdLayoutImpl(NowMsgSessionSetKbdLayout.Next());
+        }
+
+        /// <summary>
+        /// Set the previous keyboard layout for the active foreground window.
+        /// </summary>
+        public async Task SessionSetKbdLayoutPrev()
+        {
+            await SessionSetKbdLayoutImpl(NowMsgSessionSetKbdLayout.Prev());
+        }
+
+        /// <summary>
+        /// Set a specific keyboard layout for the active foreground window.
+        /// </summary>
+        public async Task SessionSetKbdLayoutSpecific(string layout)
+        {
+            await SessionSetKbdLayoutImpl(NowMsgSessionSetKbdLayout.Specific(layout));
+        }
+
         /// <summary>
         /// Start a new simple remote execution session.
         /// (see <see cref="ExecRunParams"/> for more details).

dotnet/Devolutions.NowClient/src/Worker/CommandSessionSetKbdLayout.cs

@@ -0,0 +1,12 @@
+using Devolutions.NowProto.Messages;
+
+namespace Devolutions.NowClient.Worker
+{
+    internal class CommandSessionSetKbdLayout(NowMsgSessionSetKbdLayout request) : IClientCommand
+    {
+        public async Task Execute(WorkerCtx ctx)
+        {
+            await ctx.NowChannel.WriteMessage(request);
+        }
+    }
+}

dotnet/Devolutions.NowProto.Tests/src/MsgSession.cs

@@ -119,117 +119,62 @@ public void MsgBoxRspError()
             Assert.Throws<NowProtocolException>(() => msg.GetResponseOrThrow());
         }
 
-        /*
-    let msg = NowSessionMsgBoxRspMsg::new_error(
-               0x01234567,
-               NowStatusError::from(NowStatusErrorKind::Now(NowProtoError::NotImplemented))
-                   .with_message("err")
-                   .unwrap(),
-           )
-           .unwrap();
-
-           let decoded = now_msg_roundtrip(
-               msg,
-               expect!["[15, 00, 00, 00, 12, 04, 00, 00, 67, 45, 23, 01, 00, 00, 00, 00, 03, 00, 01, 00, 07, 00, 00, 00, 03, 65, 72, 72, 00]"],
-           );
-
-           let actual = match decoded {
-               NowMessage::Session(NowSessionMessage::MsgBoxRsp(msg)) => msg,
-               _ => panic!("Expected NowSessionMsgBoxRspMsg"),
-           };
-
-           assert_eq!(actual.request_id(), 0x01234567);
-           assert_eq!(
-               actual.to_result().unwrap_err(),
-               NowStatusError::from(NowStatusErrorKind::Now(NowProtoError::NotImplemented))
-                   .with_message("err")
-                   .unwrap()
-           );
-
-                    /*
-                    [TestMethod]
-                    public void MsgLockRoundtrip()
-                    {
-                        var msg = new NowMsgSessionLock();
-
-                        var actualEncoded = new byte[(msg as INowSerialize).Size];
-                        {
-                            var cursor = new NowWriteCursor(actualEncoded);
-                            (msg as INowSerialize).Serialize(cursor);
-                        }
-
-                        var expectedEncoded = new byte[]
-                        {
-                            0x00, 0x00, 0x00, 0x00, 0x12, 0x01, 0x00, 0x00,
-                        };
-
-                        CollectionAssert.AreEqual(expectedEncoded, actualEncoded);
-                    }
-
-                    [TestMethod]
-                    public void MsgLogoff()
-                    {
-                        var msg = new NowMsgSessionLogoff();
-
-                        var actualEncoded = new byte[(msg as INowSerialize).Size];
-                        {
-                            var cursor = new NowWriteCursor(actualEncoded);
-                            (msg as INowSerialize).Serialize(cursor);
-                        }
-
-                        var expectedEncoded = new byte[]
-                        {
-                            0x00, 0x00, 0x00, 0x00, 0x12, 0x02, 0x00, 0x00,
-                        };
-
-                        CollectionAssert.AreEqual(expectedEncoded, actualEncoded);
-                    }
-
-                    [TestMethod]
-                    public void MsgMessageBoxReq()
-                    {
-                        var msg = new NowMsgSessionMessageBoxReq(0x76543210, "hello")
-                        {
-                            WaitForResponse = true,
-                            Style = NowMsgSessionMessageBoxReq.MessageBoxStyle.AbortRetryIgnore,
-                            Title = "world",
-                            Timeout = 3,
-                        };
-
-                        var actualEncoded = new byte[(msg as INowSerialize).Size];
-                        {
-                            var cursor = new NowWriteCursor(actualEncoded);
-                            (msg as INowSerialize).Serialize(cursor);
-                        }
-
-                        var expectedEncoded = new byte[]
-                        {
-                            0x1A, 0x00, 0x00, 0x00, 0x12, 0x03, 0x0F, 0x00,
-                            0x10, 0x32, 0x54, 0x76, 0x02, 0x00, 0x00, 0x00,
-                            0x03, 0x00, 0x00, 0x00, 0x05, 0x77, 0x6F, 0x72,
-                            0x6C, 0x64, 0x00, 0x05, 0x68, 0x65, 0x6C, 0x6C,
-                            0x6F, 0x00,
-                        };
-
-                        CollectionAssert.AreEqual(expectedEncoded, actualEncoded);
-                    }
-
-                    [TestMethod]
-                    public void MsgMessageBoxRsp()
-                    {
-                        var encoded = new byte[]
-                        {
-                            0x08, 0x00, 0x00, 0x00, 0x12, 0x04, 0x00, 0x00,
-                            0x67, 0x45, 0x23, 0x01, 0x04, 0x00, 0x00, 0x00,
-                        };
-
-                        var msg = NowMessage
-                            .Read(new NowReadCursor(encoded))
-                            .Deserialize<NowMsgSessionMessageBoxRsp>();
-
-                        Assert.AreEqual((uint)0x01234567, msg.RequestId);
-                        Assert.AreEqual(NowMsgSessionMessageBoxRsp.MessageBoxResponse.Retry, msg.Response);
-                    }
-                    */
+        [Fact]
+        public void SetKbdLayoutSpecific()
+        {
+            var msg = NowMsgSessionSetKbdLayout.Specific("00000409");
+
+            var encoded = new byte[]
+            {
+                0x0A, 0x00, 0x00, 0x00, 0x12, 0x05, 0x00, 0x00, 0x08, 0x30, 0x30, 0x30,
+                0x30, 0x30, 0x34, 0x30, 0x39, 0x00
+            };
+
+            var decoded = NowTest.MessageRoundtrip(msg, encoded);
+
+            Assert.Equal(msg.LayoutOption, decoded.LayoutOption);
+            Assert.Equal(msg.Layout, decoded.Layout);
+
+            Assert.Equal(NowMsgSessionSetKbdLayout.SetKbdLayoutOption.Specific, msg.LayoutOption);
+            Assert.Equal("00000409", msg.Layout);
+        }
+
+        [Fact]
+        public void SetKbdLayoutNext()
+        {
+            var msg = NowMsgSessionSetKbdLayout.Next();
+
+            var encoded = new byte[]
+            {
+                0x02, 0x00, 0x00, 0x00, 0x12, 0x05, 0x01, 0x00, 0x00, 0x00
+            };
+
+            var decoded = NowTest.MessageRoundtrip(msg, encoded);
+
+            Assert.Equal(msg.LayoutOption, decoded.LayoutOption);
+            Assert.Equal(msg.Layout, decoded.Layout);
+
+            Assert.Equal(NowMsgSessionSetKbdLayout.SetKbdLayoutOption.Next, msg.LayoutOption);
+            Assert.Null(msg.Layout);
+        }
+
+        [Fact]
+        public void SetKbdLayoutPrev()
+        {
+            var msg = NowMsgSessionSetKbdLayout.Prev();
+
+            var encoded = new byte[]
+            {
+                0x02, 0x00, 0x00, 0x00, 0x12, 0x05, 0x02, 0x00, 0x00, 0x00
+            };
+
+            var decoded = NowTest.MessageRoundtrip(msg, encoded);
+
+            Assert.Equal(msg.LayoutOption, decoded.LayoutOption);
+            Assert.Equal(msg.Layout, decoded.Layout);
+
+            Assert.Equal(NowMsgSessionSetKbdLayout.SetKbdLayoutOption.Prev, msg.LayoutOption);
+            Assert.Null(msg.Layout);
+        }
     }
 }

dotnet/Devolutions.NowProto/src/Capabilities/NowCapabilitySession.cs

@@ -28,6 +28,12 @@ public enum NowCapabilitySession : ushort
         /// NOW-PROTO: NOW_CAP_SESSION_MSGBOX
         /// </summary>
         Msgbox = 0x0004,
+        /// <summary>
+        /// Set keyboard layout command support.
+        ///
+        /// NOW-PROTO: NOW_CAP_SESSION_SET_KBD_LAYOUT
+        /// </summary>
+        SetKbdLayout = 0x0008,
 
         All = Lock | Logoff | Msgbox,
     }

dotnet/Devolutions.NowProto/src/Exceptions/NowDecodeException.cs

@@ -20,6 +20,7 @@ public enum ErrorKind
             UnexpectedMessageKind,
             InvalidDataStreamFlags,
             InvalidApartmentStateFlags,
+            InvalidKbdLayoutFlags,
         }
 
         private static string KindToMessage(ErrorKind kind)
@@ -31,6 +32,7 @@ private static string KindToMessage(ErrorKind kind)
                 ErrorKind.UnexpectedMessageKind => "Unexpected message kind.",
                 ErrorKind.InvalidDataStreamFlags => "Invalid data stream flags.",
                 ErrorKind.InvalidApartmentStateFlags => "Invalid apartment state flags.",
+                ErrorKind.InvalidKbdLayoutFlags => "Invalid keyboard layout flags.",
                 _ => throw new UnreachableException("Should not be constructed with invalid kind."),
             };
         }