Refactor storage APIs and add preferences/secure storage C API

Split preferences and secure storage C APIs into separate files, replacing storage_c.cpp/h with preferences_c.cpp/h and secure_storage_c.cpp/h. Updated includes and usage throughout the codebase. Refactored string allocation to use to_c_str/free_c_str for consistency and safety. Improved memory management and error handling in menu and window C APIs.

Author: lijy91

include/nativeapi.h

@@ -36,8 +36,9 @@
 #include "../src/capi/image_c.h"
 #include "../src/capi/keyboard_monitor_c.h"
 #include "../src/capi/menu_c.h"
+#include "../src/capi/preferences_c.h"
 #include "../src/capi/run_example_app_c.h"
-#include "../src/capi/storage_c.h"
+#include "../src/capi/secure_storage_c.h"
 #include "../src/capi/string_utils_c.h"
 #include "../src/capi/tray_icon_c.h"
 #include "../src/capi/tray_manager_c.h"

src/capi/menu_c.cpp

@@ -9,6 +9,7 @@
 #include "../global_registry.h"
 #include "../image.h"
 #include "../menu.h"
+#include "string_utils_c.h"
 
 using namespace nativeapi;
 
@@ -243,13 +244,7 @@ char* native_menu_item_get_label(native_menu_item_t item) {
     }
 
     const std::string& label = labelOpt.value();
-
-    // Allocate C string and copy content
-    char* result = static_cast<char*>(malloc(label.length() + 1));
-    if (result) {
-      strcpy(result, label.c_str());
-    }
-    return result;
+    return to_c_str(label);
   } catch (...) {
     return nullptr;
   }
@@ -321,13 +316,7 @@ char* native_menu_item_get_tooltip(native_menu_item_t item) {
     }
 
     const std::string& tooltip = tooltipOpt.value();
-
-    // Allocate C string and copy content
-    char* result = static_cast<char*>(malloc(tooltip.length() + 1));
-    if (result) {
-      strcpy(result, tooltip.c_str());
-    }
-    return result;
+    return to_c_str(tooltip);
   } catch (...) {
     return nullptr;
   }
@@ -993,13 +982,7 @@ char* native_keyboard_accelerator_to_string(const native_keyboard_accelerator_t*
   try {
     KeyboardAccelerator cpp_accelerator = convert_keyboard_accelerator(accelerator);
     std::string str = cpp_accelerator.ToString();
-
-    // Allocate C string and copy content
-    char* result = static_cast<char*>(malloc(str.length() + 1));
-    if (result) {
-      strcpy(result, str.c_str());
-    }
-    return result;
+    return to_c_str(str);
   } catch (...) {
     return nullptr;
   }

src/capi/preferences_c.cpp

@@ -0,0 +1,166 @@
+#include "preferences_c.h"
+#include "../preferences.h"
+#include "string_utils_c.h"
+
+using namespace nativeapi;
+
+// Preferences C API Implementation
+
+native_preferences_t native_preferences_create(void) {
+  try {
+    auto* prefs = new Preferences();
+    return static_cast<void*>(prefs);
+  } catch (...) {
+    return nullptr;
+  }
+}
+
+native_preferences_t native_preferences_create_with_scope(const char* scope) {
+  if (!scope) {
+    return nullptr;
+  }
+
+  try {
+    auto* prefs = new Preferences(scope);
+    return static_cast<void*>(prefs);
+  } catch (...) {
+    return nullptr;
+  }
+}
+
+void native_preferences_destroy(native_preferences_t prefs) {
+  if (prefs) {
+    delete static_cast<Preferences*>(prefs);
+  }
+}
+
+bool native_preferences_set(native_preferences_t prefs, const char* key, const char* value) {
+  if (!prefs || !key || !value) {
+    return false;
+  }
+
+  try {
+    auto* preferences = static_cast<Preferences*>(prefs);
+    return preferences->Set(key, value);
+  } catch (...) {
+    return false;
+  }
+}
+
+char* native_preferences_get(native_preferences_t prefs,
+                             const char* key,
+                             const char* default_value) {
+  if (!prefs || !key) {
+    return default_value ? to_c_str(std::string(default_value)) : nullptr;
+  }
+
+  try {
+    auto* preferences = static_cast<Preferences*>(prefs);
+    std::string result = preferences->Get(key, default_value ? default_value : "");
+    return to_c_str(result);
+  } catch (...) {
+    return default_value ? to_c_str(std::string(default_value)) : nullptr;
+  }
+}
+
+bool native_preferences_remove(native_preferences_t prefs, const char* key) {
+  if (!prefs || !key) {
+    return false;
+  }
+
+  try {
+    auto* preferences = static_cast<Preferences*>(prefs);
+    return preferences->Remove(key);
+  } catch (...) {
+    return false;
+  }
+}
+
+bool native_preferences_clear(native_preferences_t prefs) {
+  if (!prefs) {
+    return false;
+  }
+
+  try {
+    auto* preferences = static_cast<Preferences*>(prefs);
+    return preferences->Clear();
+  } catch (...) {
+    return false;
+  }
+}
+
+bool native_preferences_contains(native_preferences_t prefs, const char* key) {
+  if (!prefs || !key) {
+    return false;
+  }
+
+  try {
+    auto* preferences = static_cast<Preferences*>(prefs);
+    return preferences->Contains(key);
+  } catch (...) {
+    return false;
+  }
+}
+
+bool native_preferences_get_keys(native_preferences_t prefs, char*** out_keys, size_t* out_count) {
+  if (!prefs || !out_keys || !out_count) {
+    return false;
+  }
+
+  try {
+    auto* preferences = static_cast<Preferences*>(prefs);
+    auto keys = preferences->GetKeys();
+
+    *out_count = keys.size();
+    *out_keys = new char*[keys.size()];
+
+    for (size_t i = 0; i < keys.size(); ++i) {
+      (*out_keys)[i] = to_c_str(keys[i]);
+    }
+
+    return true;
+  } catch (...) {
+    *out_keys = nullptr;
+    *out_count = 0;
+    return false;
+  }
+}
+
+size_t native_preferences_get_size(native_preferences_t prefs) {
+  if (!prefs) {
+    return 0;
+  }
+
+  try {
+    auto* preferences = static_cast<Preferences*>(prefs);
+    return preferences->GetSize();
+  } catch (...) {
+    return 0;
+  }
+}
+
+char* native_preferences_get_scope(native_preferences_t prefs) {
+  if (!prefs) {
+    return nullptr;
+  }
+
+  try {
+    auto* preferences = static_cast<Preferences*>(prefs);
+    return to_c_str(preferences->GetScope());
+  } catch (...) {
+    return nullptr;
+  }
+}
+
+void native_preferences_free_string(char* str) {
+  free_c_str(str);
+}
+
+void native_preferences_free_string_array(char** strings, size_t count) {
+  if (strings) {
+    for (size_t i = 0; i < count; ++i) {
+      free_c_str(strings[i]);
+    }
+    delete[] strings;
+  }
+}

src/capi/preferences_c.h

@@ -0,0 +1,115 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stddef.h>
+
+// Opaque handle type
+typedef void* native_preferences_t;
+
+// Preferences API
+
+/**
+ * @brief Create a preferences storage with default scope.
+ * @return Handle to preferences storage, or NULL on failure
+ */
+native_preferences_t native_preferences_create(void);
+
+/**
+ * @brief Create a preferences storage with custom scope.
+ * @param scope Scope for isolating preferences
+ * @return Handle to preferences storage, or NULL on failure
+ */
+native_preferences_t native_preferences_create_with_scope(const char* scope);
+
+/**
+ * @brief Destroy a preferences storage instance.
+ * @param prefs Handle to preferences storage
+ */
+void native_preferences_destroy(native_preferences_t prefs);
+
+/**
+ * @brief Set a key-value pair.
+ * @param prefs Handle to preferences storage
+ * @param key The key to set
+ * @param value The value to store
+ * @return true if successful, false otherwise
+ */
+bool native_preferences_set(native_preferences_t prefs, const char* key, const char* value);
+
+/**
+ * @brief Get the value for a given key.
+ * @param prefs Handle to preferences storage
+ * @param key The key to retrieve
+ * @param default_value Default value if key doesn't exist
+ * @return The stored value or default_value. Caller must free the returned string.
+ */
+char* native_preferences_get(native_preferences_t prefs,
+                             const char* key,
+                             const char* default_value);
+
+/**
+ * @brief Remove a key-value pair.
+ * @param prefs Handle to preferences storage
+ * @param key The key to remove
+ * @return true if successful, false if key doesn't exist
+ */
+bool native_preferences_remove(native_preferences_t prefs, const char* key);
+
+/**
+ * @brief Clear all key-value pairs.
+ * @param prefs Handle to preferences storage
+ * @return true if successful, false otherwise
+ */
+bool native_preferences_clear(native_preferences_t prefs);
+
+/**
+ * @brief Check if a key exists.
+ * @param prefs Handle to preferences storage
+ * @param key The key to check
+ * @return true if key exists, false otherwise
+ */
+bool native_preferences_contains(native_preferences_t prefs, const char* key);
+
+/**
+ * @brief Get all keys.
+ * @param prefs Handle to preferences storage
+ * @param out_keys Pointer to array of keys (allocated by function)
+ * @param out_count Pointer to receive number of keys
+ * @return true if successful, false otherwise. Caller must free each key and the array.
+ */
+bool native_preferences_get_keys(native_preferences_t prefs, char*** out_keys, size_t* out_count);
+
+/**
+ * @brief Get the number of stored items.
+ * @param prefs Handle to preferences storage
+ * @return Number of key-value pairs
+ */
+size_t native_preferences_get_size(native_preferences_t prefs);
+
+/**
+ * @brief Get the scope.
+ * @param prefs Handle to preferences storage
+ * @return The scope. Caller must free the returned string.
+ */
+char* native_preferences_get_scope(native_preferences_t prefs);
+
+/**
+ * @brief Free a string returned by preferences functions.
+ * @param str String to free
+ */
+void native_preferences_free_string(char* str);
+
+/**
+ * @brief Free a string array returned by preferences functions.
+ * @param strings Array of strings to free
+ * @param count Number of strings in the array
+ */
+void native_preferences_free_string_array(char** strings, size_t count);
+
+#ifdef __cplusplus
+}
+#endif