[NativeAPI] Almost all the implementations for now

Author: Lilyltt

Lagrange.Core.NativeAPI/Context.cs

@@ -8,8 +8,10 @@ public Context(BotContext botContext)
         {
             BotContext = botContext;
             EventInvoker = new ReverseEventInvoker(BotContext);
+            SendMessageContext = new SendMessageContext(BotContext);
         }
         public BotContext BotContext { get; set; }
         public ReverseEventInvoker EventInvoker { get; set; }
+        public SendMessageContext SendMessageContext { get; set; }
     }
 }

Lagrange.Core.NativeAPI/Lagrange.Core.NativeAPI.csproj

@@ -4,6 +4,7 @@
         <TargetFramework>net9.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
+        <PublishAot>true</PublishAot>
     </PropertyGroup>
 
     <ItemGroup>

Lagrange.Core.NativeAPI/NativeModel/Common/BotConfigStruct.cs

@@ -1,4 +1,5 @@
 using System.Runtime.InteropServices;
+using Lagrange.Core.Common;
 
 namespace Lagrange.Core.NativeAPI.NativeModel.Context
 {
@@ -22,5 +23,33 @@ public BotConfigStruct()
         public uint HighwayConcurrent { get; set; } = 4;
 
         public bool AutoReLogin { get; set; } = true;
+        
+        public static implicit operator BotConfig(BotConfigStruct config)
+        {
+            return new BotConfig()
+            {
+                Protocol = (Protocols)config.Protocol,
+                AutoReconnect = config.AutoReconnect,
+                UseIPv6Network = config.UseIPv6Network,
+                GetOptimumServer = config.GetOptimumServer,
+                HighwayChunkSize = config.HighwayChunkSize,
+                HighwayConcurrent = config.HighwayConcurrent,
+                AutoReLogin = config.AutoReLogin
+            };
+        }
+        
+        public static implicit operator BotConfigStruct(BotConfig config)
+        {
+            return new BotConfigStruct()
+            {
+                Protocol = (byte)config.Protocol,
+                AutoReconnect = config.AutoReconnect,
+                UseIPv6Network = config.UseIPv6Network,
+                GetOptimumServer = config.GetOptimumServer,
+                HighwayChunkSize = config.HighwayChunkSize,
+                HighwayConcurrent = config.HighwayConcurrent,
+                AutoReLogin = config.AutoReLogin
+            };
+        }
     }
 }

Lagrange.Core.NativeAPI/NativeModel/Common/BotFriendCategoryStruct.cs

@@ -1,3 +1,6 @@
+using System.Text;
+using Lagrange.Core.Common.Entity;
+
 namespace Lagrange.Core.NativeAPI.NativeModel.Common
 {
     public struct BotFriendCategoryStruct
@@ -6,10 +9,31 @@ public BotFriendCategoryStruct() { }
 
         public int Id = 0;
 
-        public byte[] Name = [];
+        public ByteArrayNative Name = new();
 
         public int Count = 0;
 
         public int SortId = 0;
+        
+        public static implicit operator BotFriendCategoryStruct(BotFriendCategory category)
+        {
+            return new BotFriendCategoryStruct()
+            {
+                Id = category.Id,
+                Name = Encoding.UTF8.GetBytes(category.Name),
+                Count = category.Count,
+                SortId = category.SortId
+            };
+        }
+        
+        public static implicit operator BotFriendCategory(BotFriendCategoryStruct category)
+        {
+            return new BotFriendCategory(
+                category.Id,
+                Encoding.UTF8.GetString(category.Name),
+                category.Count,
+                category.SortId
+            );
+        }
     }
 }

Lagrange.Core.NativeAPI/NativeModel/Common/BotKeystoreStruct.cs

@@ -1,3 +1,5 @@
+using System.Text;
+using Lagrange.Core.Common;
 using Lagrange.Core.NativeAPI.NativeModel.Common;
 
 namespace Lagrange.Core.NativeAPI.NativeModel.Context
@@ -6,54 +8,138 @@ public struct BotKeystoreStruct
     {
         public BotKeystoreStruct() { }
 
-        public long Uin { get; set; } = 0;
+        public long Uin = 0;
 
-        public byte[] Uid { get; set; } = [];
+        public ByteArrayNative Uid = new();
 
-        public byte[] Guid { get; set; } = [];
+        public ByteArrayNative Guid = new();
 
-        public byte[] AndroidId { get; set; } = [];
+        public ByteArrayNative AndroidId = new();
 
-        public byte[] Qimei { get; set; } = [];
+        public ByteArrayNative Qimei = new();
 
-        public byte[] DeviceName { get; set; } = [];
+        public ByteArrayNative DeviceName = new();
 
         // WLoginSigs
 
-        public byte[] A2 { get; set; } = [];
-
-        public byte[] A2Key { get; set; } = new byte[16];
-
-        public byte[] D2 { get; set; } = [];
-
-        public byte[] D2Key { get; set; } = new byte[16];
-
-        public byte[] A1 { get; set; } = [];
-
-        public byte[] A1Key { get; set; } = new byte[16];
-
-        public byte[] NoPicSig { get; set; } = [];
-
-        public byte[] TgtgtKey { get; set; } = [];
-
-        public byte[] Ksid { get; set; } = [];
-
-        public byte[] SuperKey { get; set; } = [];
-
-        public byte[] StKey { get; set; } = [];
-
-        public byte[] StWeb { get; set; } = [];
-
-        public byte[] St { get; set; } = [];
-
-        public byte[] WtSessionTicket { get; set; } = [];
-
-        public byte[] WtSessionTicketKey { get; set; } = [];
-
-        public byte[] RandomKey { get; set; } = new byte[16];
-
-        public byte[] SKey { get; set; } = [];
-
-        public KeyValuePairNative<byte[], byte[]>[] PsKey { get; set; } = [];
+        public ByteArrayNative A2 = new();
+
+        public ByteArrayNative A2Key = new byte[16];
+
+        public ByteArrayNative D2 = new();
+
+        public ByteArrayNative D2Key = new byte[16];
+
+        public ByteArrayNative A1 = new();
+
+        public ByteArrayNative A1Key = new byte[16];
+
+        public ByteArrayNative NoPicSig = new();
+
+        public ByteArrayNative TgtgtKey = new();
+
+        public ByteArrayNative Ksid = new();
+
+        public ByteArrayNative SuperKey = new();
+
+        public ByteArrayNative StKey = new();
+
+        public ByteArrayNative StWeb = new();
+
+        public ByteArrayNative St = new();
+
+        public ByteArrayNative WtSessionTicket = new();
+
+        public ByteArrayNative WtSessionTicketKey = new();
+
+        public ByteArrayNative RandomKey = new byte[16];
+
+        public ByteArrayNative SKey = new();
+
+        public KeyValuePairNative<ByteArrayNative, ByteArrayNative>[] PsKey = [];
+
+        public static implicit operator BotKeystore(BotKeystoreStruct keystore)
+        {
+            var psKey = new Dictionary<string, string>();
+            foreach (var kvp in keystore.PsKey)
+            {
+                psKey[Encoding.UTF8.GetString(kvp.Key)] = Encoding.UTF8.GetString(kvp.Value);
+            }
+
+            return new BotKeystore()
+            {
+                Uin = keystore.Uin,
+                Uid = Encoding.UTF8.GetString(keystore.Uid),
+                Guid = keystore.Guid,
+                AndroidId = Encoding.UTF8.GetString(keystore.AndroidId),
+                Qimei = Encoding.UTF8.GetString(keystore.Qimei),
+                DeviceName = Encoding.UTF8.GetString(keystore.DeviceName),
+                WLoginSigs = new WLoginSigs()
+                {
+                    A2 = keystore.A2,
+                    A2Key = keystore.A2Key,
+                    D2 = keystore.D2,
+                    D2Key = keystore.D2Key,
+                    A1 = keystore.A1,
+                    A1Key = keystore.A1Key,
+                    NoPicSig = keystore.NoPicSig,
+                    TgtgtKey = keystore.TgtgtKey,
+                    Ksid = keystore.Ksid,
+                    SuperKey = keystore.SuperKey,
+                    StKey = keystore.StKey,
+                    StWeb = keystore.StWeb,
+                    St = keystore.St,
+                    WtSessionTicket = keystore.WtSessionTicket,
+                    WtSessionTicketKey = keystore.WtSessionTicketKey,
+                    RandomKey = keystore.RandomKey,
+                    SKey = keystore.SKey,
+                    PsKey = psKey
+                }
+            };
+        }
+
+        public static implicit operator BotKeystoreStruct(BotKeystore keystore)
+        {
+            var bytePsKey = new KeyValuePairNative<ByteArrayNative, ByteArrayNative>[
+                keystore.WLoginSigs.PsKey.Count
+            ];
+            int i = 0;
+            foreach (var kvp in keystore.WLoginSigs.PsKey)
+            {
+                bytePsKey[i++] = new KeyValuePairNative<ByteArrayNative, ByteArrayNative>()
+                {
+                    Key = Encoding.UTF8.GetBytes(kvp.Key),
+                    Value = Encoding.UTF8.GetBytes(kvp.Value)
+                };
+            }
+
+            return new BotKeystoreStruct()
+            {
+                Uin = keystore.Uin,
+                Uid = Encoding.UTF8.GetBytes(keystore.Uid),
+                Guid = keystore.Guid,
+                AndroidId = Encoding.UTF8.GetBytes(keystore.AndroidId),
+                Qimei = Encoding.UTF8.GetBytes(keystore.Qimei),
+                DeviceName = Encoding.UTF8.GetBytes(keystore.DeviceName),
+                A2 = keystore.WLoginSigs.A2,
+                A2Key = keystore.WLoginSigs.A2Key,
+                D2 = keystore.WLoginSigs.D2,
+                D2Key = keystore.WLoginSigs.D2Key,
+                A1 = keystore.WLoginSigs.A1,
+                A1Key = keystore.WLoginSigs.A1Key,
+                NoPicSig = keystore.WLoginSigs.NoPicSig,
+                TgtgtKey = keystore.WLoginSigs.TgtgtKey,
+                Ksid = keystore.WLoginSigs.Ksid,
+                SuperKey = keystore.WLoginSigs.SuperKey,
+                StKey = keystore.WLoginSigs.StKey,
+                StWeb = keystore.WLoginSigs.StWeb,
+                St = keystore.WLoginSigs.St,
+                WtSessionTicket = keystore.WLoginSigs.WtSessionTicket,
+                WtSessionTicketKey = keystore.WLoginSigs.WtSessionTicketKey,
+                RandomKey = keystore.WLoginSigs.RandomKey,
+                SKey = keystore.WLoginSigs.SKey,
+                PsKey = bytePsKey
+            };
+        }
     }
 }

Lagrange.Core.NativeAPI/NativeModel/Common/ByteArrayNative.cs

@@ -0,0 +1,45 @@
+using System.Runtime.InteropServices;
+
+namespace Lagrange.Core.NativeAPI.NativeModel.Common
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public struct ByteArrayNative
+    {
+        public int Length;
+        public IntPtr Data;
+
+        public static implicit operator ByteArrayNative(byte[] bytes)
+        {
+            IntPtr ptr = Marshal.AllocHGlobal(bytes.Length);
+            Marshal.Copy(bytes, 0, ptr, bytes.Length);
+
+            return new ByteArrayNative { Length = bytes.Length, Data = ptr };
+        }
+        
+        public static implicit operator byte[](ByteArrayNative byteArray)
+        {
+            if (byteArray.Data == IntPtr.Zero)
+            {
+                return [];
+            }
+            byte[] bytes = new byte[byteArray.Length];
+            Marshal.Copy(byteArray.Data, bytes, 0, byteArray.Length);
+            
+            Marshal.FreeHGlobal(byteArray.Data);
+            
+            return bytes;
+        }
+
+        public byte[] ToByteArrayWithoutFree()
+        {
+            byte[] bytes = new byte[Length];
+            Marshal.Copy(Data, bytes, 0, Length);
+            return bytes;
+        }
+        
+        public bool IsEmpty()
+        {
+            return Length == 0 || Data == IntPtr.Zero;
+        }
+    }
+}

Lagrange.Core.NativeAPI/NativeModel/Event/BotCaptchaEventStruct.cs

@@ -1,9 +1,26 @@
+using System.Text;
+using Lagrange.Core.Events.EventArgs;
+using Lagrange.Core.NativeAPI.NativeModel.Common;
+
 namespace Lagrange.Core.NativeAPI.NativeModel.Event
 {
     public struct BotCaptchaEventStruct : IEventStruct
     {
         public BotCaptchaEventStruct() { }
+
+        public ByteArrayNative CaptchaUrl = new();
+
+        public static implicit operator BotCaptchaEventStruct(BotCaptchaEvent e)
+        {
+            return new BotCaptchaEventStruct()
+            {
+                CaptchaUrl = Encoding.UTF8.GetBytes(e.CaptchaUrl)
+            };
+        }
 
-        public byte[] CaptchaUrl = [];
+        public static implicit operator BotCaptchaEvent(BotCaptchaEventStruct e)
+        {
+            return new BotCaptchaEvent(Encoding.UTF8.GetString(e.CaptchaUrl));
+        }
     }
-}
+}