simplejsble 0.0.48 → 0.0.49

package/apple/SimpleBLE.xcframework/Info.plist

@@ -10,17 +10,16 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64-simulator</string>
+			<string>macos-arm64_x86_64</string>
 			<key>LibraryPath</key>
 			<string>libsimpleble.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
-			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
+			<string>macos</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -28,16 +27,15 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>macos-arm64_x86_64</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libsimpleble.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
-			<string>macos</string>
+			<string>ios</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -45,7 +43,7 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libsimpleble.a</string>
 			<key>SupportedArchitectures</key>
@@ -54,6 +52,8 @@
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/cpp/HybridCharacteristic.cpp

@@ -11,9 +11,9 @@ std::string HybridCharacteristic::uuid() {
     return _characteristic.uuid();
 }
 
-std::vector<std::shared_ptr<HybridDescriptor>> HybridCharacteristic::descriptors() {
+std::vector<std::shared_ptr<HybridDescriptorSpec>> HybridCharacteristic::descriptors() {
     std::vector<SimpleBLE::Descriptor> characteristic_descriptors = _characteristic.descriptors();
-    std::vector<std::shared_ptr<HybridDescriptor>> hybrid_descriptors;
+    std::vector<std::shared_ptr<HybridDescriptorSpec>> hybrid_descriptors;
     hybrid_descriptors.reserve(characteristic_descriptors.size());
     
     for (auto& descriptor : characteristic_descriptors) {

package/cpp/HybridCharacteristic.hpp

@@ -9,7 +9,7 @@
 namespace margelo::nitro::simplejsble {
 
 // Forward declaration
-class HybridDescriptor;
+class HybridDescriptorSpec;
 
 class HybridCharacteristic : public HybridCharacteristicSpec {
   public:
@@ -19,7 +19,7 @@ class HybridCharacteristic : public HybridCharacteristicSpec {
 
     bool initialized() override;
     std::string uuid() override;
-    std::vector<std::shared_ptr<HybridDescriptor>> descriptors() override;
+    std::vector<std::shared_ptr<HybridDescriptorSpec>> descriptors() override;
     std::vector<std::string> capabilities() override;
     bool can_read() override;
     bool can_write_request() override;

package/cpp/HybridPeripheral.cpp

@@ -81,9 +81,9 @@ void HybridPeripheral::set_callback_on_disconnected(const std::function<void()>&
     });
 }
 
-std::vector<std::shared_ptr<HybridService>> HybridPeripheral::services() {
+std::vector<std::shared_ptr<HybridServiceSpec>> HybridPeripheral::services() {
     std::vector<SimpleBLE::Service> peripheral_services = _peripheral.services();
-    std::vector<std::shared_ptr<HybridService>> hybrid_services;
+    std::vector<std::shared_ptr<HybridServiceSpec>> hybrid_services;
     hybrid_services.reserve(peripheral_services.size());
     
     for (auto& service : peripheral_services) {
@@ -93,9 +93,9 @@ std::vector<std::shared_ptr<HybridService>> HybridPeripheral::services() {
     return hybrid_services;
 }
 
-std::unordered_map<double, ArrayBuffer> HybridPeripheral::manufacturer_data() {
+std::unordered_map<double, std::shared_ptr<ArrayBuffer>> HybridPeripheral::manufacturer_data() {
     std::map<uint16_t, SimpleBLE::ByteArray> peripheral_manufacturer_data = _peripheral.manufacturer_data();
-    std::unordered_map<double, ArrayBuffer> manufacturer_array_buffer_map;
+    std::unordered_map<double, std::shared_ptr<ArrayBuffer>> manufacturer_array_buffer_map;
     
     for (const auto& pair : peripheral_manufacturer_data) {
         manufacturer_array_buffer_map[static_cast<double>(pair.first)] = toArrayBuffer(pair.second);
@@ -104,23 +104,23 @@ std::unordered_map<double, ArrayBuffer> HybridPeripheral::manufacturer_data() {
     return manufacturer_array_buffer_map;
 }
 
-ArrayBuffer HybridPeripheral::read(const std::string& service, const std::string& characteristic) {
+std::shared_ptr<ArrayBuffer> HybridPeripheral::read(const std::string& service, const std::string& characteristic) {
     SimpleBLE::ByteArray peripheral_read_data = _peripheral.read(service, characteristic);
     return toArrayBuffer(peripheral_read_data);
 }
 
-void HybridPeripheral::write_request(const std::string& service, const std::string& characteristic, ArrayBuffer data) {
+void HybridPeripheral::write_request(const std::string& service, const std::string& characteristic, const std::shared_ptr<ArrayBuffer>& data) {
     SimpleBLE::ByteArray bytes = fromArrayBuffer(data);
     _peripheral.write_request(service, characteristic, bytes);
 }
 
-void HybridPeripheral::write_command(const std::string& service, const std::string& characteristic, ArrayBuffer data) {
+void HybridPeripheral::write_command(const std::string& service, const std::string& characteristic, const std::shared_ptr<ArrayBuffer>& data) {
     SimpleBLE::ByteArray bytes = fromArrayBuffer(data);
     _peripheral.write_command(service, characteristic, bytes);
 }
 
 void HybridPeripheral::notify(const std::string& service, const std::string& characteristic, 
-                              const std::function<void(ArrayBuffer)>& callback) {
+                              const std::function<void(const std::shared_ptr<ArrayBuffer>&)>& callback) {
     auto key = std::make_pair(service, characteristic);
     _notifyCallbacks[key] = callback;
     
@@ -133,7 +133,7 @@ void HybridPeripheral::notify(const std::string& service, const std::string& cha
 }
 
 void HybridPeripheral::indicate(const std::string& service, const std::string& characteristic, 
-                                const std::function<void(ArrayBuffer)>& callback) {
+                                const std::function<void(const std::shared_ptr<ArrayBuffer>&)>& callback) {
     auto key = std::make_pair(service, characteristic);
     _notifyCallbacks[key] = callback; //@alejo: verify if its necessary to store our own reference to the callback
     
@@ -151,27 +151,27 @@ void HybridPeripheral::unsubscribe(const std::string& service, const std::string
     _peripheral.unsubscribe(service, characteristic);
 }
 
-ArrayBuffer HybridPeripheral::read_descriptor(const std::string& service, const std::string& characteristic, 
+std::shared_ptr<ArrayBuffer> HybridPeripheral::read_descriptor(const std::string& service, const std::string& characteristic, 
                                               const std::string& descriptor) {
     SimpleBLE::ByteArray peripheral_descriptor_data = _peripheral.read(service, characteristic, descriptor);
     return toArrayBuffer(peripheral_descriptor_data);
 }
 
 void HybridPeripheral::write_descriptor(const std::string& service, const std::string& characteristic, 
-                                       const std::string& descriptor, ArrayBuffer data) {
+                                       const std::string& descriptor, const std::shared_ptr<ArrayBuffer>& data) {
     SimpleBLE::ByteArray bytes = fromArrayBuffer(data);
     _peripheral.write(service, characteristic, descriptor, bytes);
 }
 
 // Helper methods to cast between SimpleBLE::ByteArray and ArrayBuffer (NitroModules native type)
-ArrayBuffer HybridPeripheral::toArrayBuffer(const SimpleBLE::ByteArray& data) {
-    return ArrayBuffer(reinterpret_cast<const uint8_t*>(data.data()), data.size());
+std::shared_ptr<ArrayBuffer> HybridPeripheral::toArrayBuffer(const SimpleBLE::ByteArray& data) {
+    return std::make_shared<ArrayBuffer>(reinterpret_cast<const uint8_t*>(data.data()), data.size());
 }
 
-SimpleBLE::ByteArray HybridPeripheral::fromArrayBuffer(const ArrayBuffer& buffer) {
+SimpleBLE::ByteArray HybridPeripheral::fromArrayBuffer(const std::shared_ptr<ArrayBuffer>& buffer) {
     return SimpleBLE::ByteArray(
-        static_cast<const uint8_t*>(buffer.data()), 
-        buffer.size()
+        static_cast<const uint8_t*>(buffer->data()), 
+        buffer->size()
     );
 }
 

package/cpp/HybridPeripheral.hpp

@@ -6,11 +6,12 @@
 #include <functional>
 #include <string>
 #include <map>
+#include <unordered_map>
 #include <utility>
 
 namespace margelo::nitro::simplejsble {
 
-class HybridService;
+class HybridServiceSpec;
 
 class HybridPeripheral : public HybridPeripheralSpec {
   public:
@@ -36,22 +37,22 @@ class HybridPeripheral : public HybridPeripheralSpec {
     void set_callback_on_connected(const std::function<void()>& callback) override;
     void set_callback_on_disconnected(const std::function<void()>& callback) override;
 
-    std::vector<std::shared_ptr<HybridService>> services() override;
-    std::unordered_map<double, ArrayBuffer> manufacturer_data() override;
+    std::vector<std::shared_ptr<HybridServiceSpec>> services() override;
+    std::unordered_map<double, std::shared_ptr<ArrayBuffer>> manufacturer_data() override;
 
-    ArrayBuffer read(const std::string& service, const std::string& characteristic) override;
-    void write_request(const std::string& service, const std::string& characteristic, ArrayBuffer data) override;
-    void write_command(const std::string& service, const std::string& characteristic, ArrayBuffer data) override;
+    std::shared_ptr<ArrayBuffer> read(const std::string& service, const std::string& characteristic) override;
+    void write_request(const std::string& service, const std::string& characteristic, const std::shared_ptr<ArrayBuffer>& data) override;
+    void write_command(const std::string& service, const std::string& characteristic, const std::shared_ptr<ArrayBuffer>& data) override;
     void notify(const std::string& service, const std::string& characteristic, 
-                const std::function<void(ArrayBuffer)>& callback) override;
+                const std::function<void(const std::shared_ptr<ArrayBuffer>&)>& callback) override;
     void indicate(const std::string& service, const std::string& characteristic, 
-                  const std::function<void(ArrayBuffer)>& callback) override;
+                  const std::function<void(const std::shared_ptr<ArrayBuffer>&)>& callback) override;
     void unsubscribe(const std::string& service, const std::string& characteristic) override;
 
-    ArrayBuffer read_descriptor(const std::string& service, const std::string& characteristic, 
+    std::shared_ptr<ArrayBuffer> read_descriptor(const std::string& service, const std::string& characteristic, 
                                 const std::string& descriptor) override;
     void write_descriptor(const std::string& service, const std::string& characteristic, 
-                         const std::string& descriptor, ArrayBuffer data) override;
+                         const std::string& descriptor, const std::shared_ptr<ArrayBuffer>& data) override;
 
     SimpleBLE::Peripheral& getInternal() { return _peripheral; }
     const SimpleBLE::Peripheral& getInternal() const { return _peripheral; }
@@ -62,11 +63,11 @@ class HybridPeripheral : public HybridPeripheralSpec {
     std::function<void()> _onConnected;
     std::function<void()> _onDisconnected;
 
-    std::map<std::pair<std::string, std::string>, std::function<void(ArrayBuffer)>> _notifyCallbacks;
+    std::map<std::pair<std::string, std::string>, std::function<void(const std::shared_ptr<ArrayBuffer>&)>> _notifyCallbacks;
 
     // Helper methods to cast between SimpleBLE::ByteArray and ArrayBuffer (NitroModules native type)
-    static ArrayBuffer toArrayBuffer(const SimpleBLE::ByteArray& data);
-    static SimpleBLE::ByteArray fromArrayBuffer(const ArrayBuffer& buffer);
+    static std::shared_ptr<ArrayBuffer> toArrayBuffer(const SimpleBLE::ByteArray& data);
+    static SimpleBLE::ByteArray fromArrayBuffer(const std::shared_ptr<ArrayBuffer>& buffer);
 };
 
 }  // namespace margelo::nitro::simplejsble

package/cpp/HybridService.cpp

@@ -11,14 +11,14 @@ std::string HybridService::uuid() {
     return _service.uuid();
 }
 
-ArrayBuffer HybridService::data() {
+std::shared_ptr<ArrayBuffer> HybridService::data() {
     SimpleBLE::ByteArray bytes = _service.data();
-    return ArrayBuffer(reinterpret_cast<const uint8_t*>(bytes.data()), bytes.size());
+    return std::make_shared<ArrayBuffer>(reinterpret_cast<const uint8_t*>(bytes.data()), bytes.size());
 }
 
-std::vector<std::shared_ptr<HybridCharacteristic>> HybridService::characteristics() {
+std::vector<std::shared_ptr<HybridCharacteristicSpec>> HybridService::characteristics() {
     std::vector<SimpleBLE::Characteristic> service_characteristics = _service.characteristics();
-    std::vector<std::shared_ptr<HybridCharacteristic>> hybrid_characteristics;
+    std::vector<std::shared_ptr<HybridCharacteristicSpec>> hybrid_characteristics;
     hybrid_characteristics.reserve(service_characteristics.size());
     
     for (auto& characteristic : service_characteristics) {

package/cpp/HybridService.hpp

@@ -2,12 +2,13 @@
 
 #include "HybridServiceSpec.hpp"
 #include <simpleble/SimpleBLE.h>
+#include <NitroModules/ArrayBuffer.hpp>
 #include <memory>
 #include <vector>
 
 namespace margelo::nitro::simplejsble {
 
-class HybridCharacteristic;
+class HybridCharacteristicSpec;
 
 class HybridService : public HybridServiceSpec {
   public:
@@ -17,8 +18,8 @@ class HybridService : public HybridServiceSpec {
 
     bool initialized() override;
     std::string uuid() override;
-    ArrayBuffer data() override;
-    std::vector<std::shared_ptr<HybridCharacteristic>> characteristics() override;
+    std::shared_ptr<ArrayBuffer> data() override;
+    std::vector<std::shared_ptr<HybridCharacteristicSpec>> characteristics() override;
 
     SimpleBLE::Service& getInternal() { return _service; }
     const SimpleBLE::Service& getInternal() const { return _service; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simplejsble",
-  "version": "0.0.48",
+  "version": "0.0.49",
   "description": "React Native Bluetooth Low Energy library using SimpleBLE with Nitro Modules",
   "main": "lib/index",
   "module": "lib/index",