fix(dxinput): fix property reading and button mapping data processing

logic

- Replaced custom uchar array conversion function with C.GoBytes
to simplify data copying
- Modified get_prop function implementation to first obtain the
attribute data size, then read the data completely
- Corrected get_prop function parameters and comments; nbytes now
indicates byte length rather than item count
- Added free_prop_data function to release memory returned by
get_prop, preventing memory leaks
- Ensured proper release of C-allocated data after calling get_prop
to retrieve properties in the Go layer
- Removed unused maxBufferLen constant and the old ucharArrayToByte
implementation

Influence: Input Device Management

---

fix(dxinput): 修正属性读取和按钮映射数据处理逻辑

- 使用 C.GoBytes 替代自定义 uchar
数组转换函数简化数据拷贝
- 修改 get_prop
函数实现，先获取属性数据大小，再完整读取数据
- 修正 get_prop 函数参数和注释，nbytes
表示字节长度而非项目数
- 添加 free_prop_data 函数用于释放 get_prop
返回的内存，避免内存泄漏
- 在 Go 层调用 get_prop 获取属性后正确释放 C
分配的数据
- 删除无用的 maxBufferLen 常量和 ucharArrayToByte 旧实现

Influence: 输入设备管理功能

Author: electricface

dxinput/utils/button_map.go

@@ -29,7 +29,7 @@ func GetButtonMap(xid uint32, devName string) ([]byte, error) {
 	}
 	defer C.free(unsafe.Pointer(cbtnMap))
 
-	return ucharArrayToByte(cbtnMap, int(cbtnNum)), nil
+	return C.GoBytes(unsafe.Pointer(cbtnMap), cbtnNum), nil
 }
 
 func SetButtonMap(xid uint32, devName string, btnMap []byte) error {

dxinput/utils/property.c

@@ -12,26 +12,29 @@
 #include "type.h"
 #include "x11_mutex.h"
 
-#define MAX_BUF_LEN 1000
-
 /**
  *  The return data type if 'char' must be convert to 'int8_t*'
  * if 'int' must be convert to 'int32_t*'
  * if 'float' must be convert to 'float*'
+ *
+ * Returns the property data and sets nbytes to the actual byte length.
+ * The caller is responsible for calling XFree() on the returned data.
  **/
 unsigned char*
-get_prop(int id, const char* prop, int* nitems)
+get_prop(int id, const char* prop, int* nbytes)
 {
     if (!prop) {
         fprintf(stderr, "[get_prop] Empty property for %d\n", id);
         return NULL;
     }
 
-    if (!nitems) {
-        fprintf(stderr, "[get_prop] Invalid item number for %d\n", id);
+    if (!nbytes) {
+        fprintf(stderr, "[get_prop] Invalid nbytes pointer for %d\n", id);
         return NULL;
     }
 
+    *nbytes = 0;
+
     pthread_mutex_lock(&x11_global_mutex);
     setErrorHandler();
 
@@ -54,24 +57,71 @@ get_prop(int id, const char* prop, int* nitems)
     int act_format;
     unsigned long num_items, bytes_after;
     unsigned char* data = NULL;
-    int ret = XIGetProperty(disp, id, prop_id, 0, MAX_BUF_LEN, False,
+
+    // Step 1: Query property size (length=0 to get bytes_after)
+    int ret = XIGetProperty(disp, id, prop_id, 0, 0, False,
                             AnyPropertyType, &act_type, &act_format,
                             &num_items, &bytes_after, &data);
+    if (ret != Success || act_type == None) {
+        if (data) {
+            XFree(data);
+        }
+        XCloseDisplay(disp);
+        pthread_mutex_unlock(&x11_global_mutex);
+        return NULL;
+    }
+
+    if (data) {
+        XFree(data);
+        data = NULL;
+    }
+
+    if (bytes_after == 0) {
+        // Property exists but has no data
+        XCloseDisplay(disp);
+        pthread_mutex_unlock(&x11_global_mutex);
+        return NULL;
+    }
+
+    // Step 2: Read all property data
+    // length is in 32-bit units, so divide bytes_after by 4 (round up)
+    unsigned long length = (bytes_after + 3) / 4;
+
+    ret = XIGetProperty(disp, id, prop_id, 0, length, False,
+                        AnyPropertyType, &act_type, &act_format,
+                        &num_items, &bytes_after, &data);
     if (ret != Success) {
+        if (data) {
+            XFree(data);
+        }
         XCloseDisplay(disp);
         fprintf(stderr, "[get_prop] Get %s data failed for %d\n", prop, id);
         pthread_mutex_unlock(&x11_global_mutex);
         return NULL;
     }
 
-    *nitems = (int)num_items;
-    XCloseDisplay(disp);
+    // Calculate actual byte length based on format and num_items
+    // format is 8, 16, or 32 bits per item
+    *nbytes = (int)(num_items * (act_format / 8));
 
+    XCloseDisplay(disp);
     pthread_mutex_unlock(&x11_global_mutex);
 
     return data;
 }
 
+/**
+ * Free the property data returned by get_prop.
+ * This is a wrapper for XFree to be called from Go.
+ */
+void
+free_prop_data(unsigned char* data)
+{
+    if (data) {
+        XFree(data);
+    }
+}
+
 // bit: range(8,16,32)
 int
 set_prop_int(int id, const char* prop, unsigned char* data, int nitems, int bit)

dxinput/utils/property.h

@@ -7,7 +7,8 @@
 
 #include <X11/Xlib.h>
 
-unsigned char* get_prop(int id, const char* prop, int* nitems);
+unsigned char* get_prop(int id, const char* prop, int* nbytes);
+void free_prop_data(unsigned char* data);
 int set_prop_int(int id, const char* prop, unsigned char* data, int nitems, int bit);
 int set_prop_float(int id, const char* prop, unsigned char* data, int nitems);
 int set_prop(int id, const char* prop, unsigned char* data, int nitems,

dxinput/utils/wrapper.go

@@ -23,11 +23,6 @@ import (
 	"github.com/linuxdeepin/dde-api/dxinput/kwayland"
 )
 
-const (
-	// see 'property.c' MAX_BUF_LEN
-	maxBufferLen = 1000
-)
-
 func ListDevice() DeviceInfos {
 	if len(os.Getenv("WAYLAND_DISPLAY")) != 0 {
 		infos, _ := kwayland.ListDevice()
@@ -103,21 +98,19 @@ func GetProperty(id int32, prop string) ([]byte, int32) {
 	}
 
 	cprop := C.CString(prop)
+	defer C.free(unsafe.Pointer(cprop))
 
-	defer func() {
-		if cprop != nil {
-			C.free(unsafe.Pointer(cprop))
-		}
-	}()
-
-	nitems := C.int(0)
-	cdatas := C.get_prop(C.int(id), cprop, &nitems)
-	if cdatas == nil || nitems == 0 {
+	// nbytes now represents the actual byte length returned by C layer
+	nbytes := C.int(0)
+	cdatas := C.get_prop(C.int(id), cprop, &nbytes)
+	if cdatas == nil || nbytes == 0 {
 		return nil, 0
 	}
+	// XIGetProperty allocates memory for data, caller must free it with XFree
+	defer C.free_prop_data(cdatas)
 
-	datas := ucharArrayToByte(cdatas, maxBufferLen)
-	return datas, int32(nitems)
+	datas := C.GoBytes(unsafe.Pointer(cdatas), nbytes)
+	return datas, int32(nbytes)
 }
 
 func SetInt8Prop(id int32, prop string, values []int8) error {
@@ -196,25 +189,6 @@ func SetFloat32Prop(id int32, prop string, values []float32) error {
 	return nil
 }
 
-func ucharArrayToByte(cData *C.uchar, length int) []byte {
-	if cData == nil {
-		return nil
-	}
-	cItemSize := unsafe.Sizeof(*cData)
-
-	var data []byte
-	for i := 0; i < length; i++ {
-		offset := uintptr(i) * cItemSize
-		addr := uintptr(unsafe.Pointer(cData)) + offset
-		cdata := (*C.uchar)(unsafe.Pointer(addr))
-		if cdata == nil {
-			break
-		}
-		data = append(data, byte(*cdata))
-	}
-	return data
-}
-
 func byteArrayToUChar(datas []byte) []C.uchar {
 	var cdatas []C.uchar
 	for i := 0; i < len(datas); i++ {