updated callback system

libnfc_cpptools/inc/libnfc_cpptools/FreeFareTagClassic.h

 
 class FreeFareTagClassicInternal;
 
+struct FreeFareTagClassicMappingProgress
+{
+    int32_t done;
+    int32_t total;
+};
+
+struct FreeFareTagClassicReadProgress
+{
+    int32_t done;
+    int32_t total;
+};
+
+struct FreeFareTagClassicWriteProgress
+{
+    int32_t done;
+    int32_t total;
+};
+
 class FreeFareTagClassic : public FreeFareTag
 {
 public:
     LibNfc::Utils::ResultBool authenticate(int sector, const std::string& key, int keyType);
 
     LibNfc::Utils::Result<MappedKeys> mapKeys(const std::vector<std::string>& keys,
-                                              std::function<void(int, int)> cb = nullptr);
+                                              std::function<void(FreeFareTagClassicMappingProgress)> mapCb = nullptr);
 
     LibNfc::Utils::ResultString readBlock(int sector, int block, const std::string& key, int keyType);
 
     LibNfc::Utils::Result<FreeFareClassicSector> readSector(int sector, const std::string& key, int keyType);
 
     LibNfc::Utils::Result<std::vector<FreeFareClassicSector>> read(const MappedKeys& keys,
-                                                            std::function<void(int, int)> cb = nullptr);
+                                                            std::function<void(FreeFareTagClassicReadProgress)> readCb = nullptr);
 
     LibNfc::Utils::Result<std::vector<FreeFareClassicSector>> read(const std::vector<std::string>& keys,
-                                                            std::function<void(int, int)> mapCb = nullptr,
-                                                            std::function<void(int, int)> readCb = nullptr);
+                                                            std::function<void(FreeFareTagClassicMappingProgress)> mapCb = nullptr,
+                                                            std::function<void(FreeFareTagClassicReadProgress)> readCb = nullptr);
 
     LibNfc::Utils::ResultBool writeBlock(int sector,
                                          int block,
     LibNfc::Utils::ResultBool write(const MappedKeys& keys,
                                     const std::string& data,
                                     bool writeSector0,
-                                    std::function<void(int, int)> cb = nullptr);
+                                    std::function<void(FreeFareTagClassicWriteProgress)> writeCb = nullptr);
 
     LibNfc::Utils::ResultBool write(const std::vector<std::string>& keys,
                                     const std::string& data,
                                     bool writeSector0,
-                                    std::function<void(int, int)> mapCb = nullptr,
-                                    std::function<void(int, int)> writeCb = nullptr);
+                                    std::function<void(FreeFareTagClassicMappingProgress)> mapCb = nullptr,
+                                    std::function<void(FreeFareTagClassicWriteProgress)> writeCb = nullptr);
 };
 
 }; // FreeFare

libnfc_cpptools/src/freefare/Tags/Classic/FreeFareTagClassic.cpp

     return std::static_pointer_cast<FreeFareTagClassicInternal>(_tag)->authenticate(sector, key, keyType);
 }
 
-LibNfc::Utils::Result<MappedKeys> FreeFareTagClassic::mapKeys(const std::vector<std::string>& keys, std::function<void(int, int)> cb)
+LibNfc::Utils::Result<MappedKeys> FreeFareTagClassic::mapKeys(const std::vector<std::string>& keys,
+                                                              std::function<void(FreeFareTagClassicMappingProgress)> mapCb)
 {
     MappedKeys mappedKeys;
-    unsigned long done = 0;
-    unsigned long total = 16 * keys.size();
+    int32_t done = 0;
+    int32_t total = 16 * keys.size();
 
     for (int i = 0; i < 16; ++i) {
         std::pair<std::string, std::string> blockKeys;
             if (authenticate(i, key, MFC_KEY_B)) {
                 blockKeys.second = key;
             }
-            if (cb != nullptr) {
-                cb(++done, total);
+            if (mapCb != nullptr) {
+                mapCb({++done, total});
             }
             if (!blockKeys.first.empty() && !blockKeys.second.empty()) {
                 break;
         }
         mappedKeys.push_back(blockKeys);
     }
-    if (cb != nullptr && done < total) {
-        cb(total, total);
+    if (mapCb != nullptr && done < total) {
+        mapCb({total, total});
     }
 
     return LibNfc::Utils::Result<MappedKeys>::ok(mappedKeys);
     return LibNfc::Utils::Result<FreeFareClassicSector>::ok(FreeFareClassicSector(res));
 }
 
-LibNfc::Utils::Result<std::vector<FreeFareClassicSector>> FreeFareTagClassic::read(const MappedKeys& keys, std::function<void(int, int)> cb)
+LibNfc::Utils::Result<std::vector<FreeFareClassicSector>> FreeFareTagClassic::read(const MappedKeys& keys,
+                                                                                   std::function<void(FreeFareTagClassicReadProgress)> readCb)
 {
     if (keys.size() != 16) {
         return LibNfc::Utils::Result<std::vector<FreeFareClassicSector>>::error("Must have 16 sectors keys");
     }
-    int done = 0;
-    int total = 4 * keys.size();
+    int32_t done = 0;
+    int32_t total = 4 * keys.size();
     std::vector<FreeFareClassicSector> sectors;
     for (int s = 0; s < keys.size(); ++s) {
         auto sectorKey = keys[s];
         bool keyA = false;
         bool keyB = false;
         for (int b = 0; b < 3; ++b) {
-            std::string data = "";
+            std::string data;
             if (!sectorKey.first.empty()) {
                 auto blockResult = readBlock(s, b, sectorKey.first, MFC_KEY_A);
                 if (blockResult) {
                 }
             }
             sector.setBlock(b, data);
-            if (cb != nullptr) {
-                cb(++done, total);
+            if (readCb != nullptr) {
+                readCb({++done, total});
             }
         }
         int b = 3;
                 keyB = true;
             }
         }
-        if (cb != nullptr) {
-            cb(++done, total);
+        if (readCb != nullptr) {
+            readCb({++done, total});
         }
 
         sector.setBlock(b, dataA);
 
         sectors.push_back(sector);
     }
-    if (cb != nullptr && done < total) {
-        cb(total, total);
+    if (readCb != nullptr && done < total) {
+        readCb({total, total});
     }
 
     return LibNfc::Utils::Result<std::vector<FreeFareClassicSector>>::ok(sectors);
 }
 
 LibNfc::Utils::Result<std::vector<FreeFareClassicSector>> FreeFareTagClassic::read(const std::vector<std::string>& keys,
-                                                                     std::function<void(int, int)> mapCb,
-                                                                     std::function<void(int, int)> readCb)
+                                                                     std::function<void(FreeFareTagClassicMappingProgress)> mapCb,
+                                                                     std::function<void(FreeFareTagClassicReadProgress)> readCb)
 {
     auto mappedKeysResult = mapKeys(keys, mapCb);
     if (!mappedKeysResult) {
 }
 
 LibNfc::Utils::ResultBool FreeFareTagClassic::write(const MappedKeys& keys,
-                                             const std::string& data,
-                                             bool writeSector0,
-                                             std::function<void(int, int)> cb)
+                                                    const std::string& data,
+                                                    bool writeSector0,
+                                                    std::function<void(FreeFareTagClassicWriteProgress)> writeCb)
 {
     if (keys.size() != 16) {
         return LibNfc::Utils::ResultBool::error("Must have 16 sectors keys");
     }
     std::string d = LibNfc::Utils::StringUtils::ensureSize(data, 1024);
     std::string errors;
-    unsigned long done = 0;
-    unsigned long total = 4 * keys.size();
+    int32_t done = 0;
+    int32_t total = 4 * keys.size();
     for (unsigned long s = 0; s < keys.size(); ++s) {
         auto sectorKey = keys[s];
         for (int b = 0; b < 4; ++b) {
                 continue;
             }
             std::string blockData = d.substr((s * 64) + (b * 16), 16);
-            if (cb != nullptr && done < total) {
+            if (writeCb != nullptr && done < total) {
                 bool keyA = false;
                 bool keyB = false;
                 std::string sectorErrors;
                 if (!keyA && !keyB) {
                     errors += std::string(errors.empty() ? "" : "\n") + sectorErrors;
                 }
-                cb(++done, total);
+                writeCb({++done, total});
             }
         }
     }
-    if (cb != nullptr && done < total) {
-        cb(total, total);
+    if (writeCb != nullptr && done < total) {
+        writeCb({total, total});
     }
     if (errors.empty()) {
         return LibNfc::Utils::ResultBool::ok(true);
     return LibNfc::Utils::ResultBool::error(errors);
 }
 
-LibNfc::Utils::ResultBool FreeFareTagClassic::write(const std::vector<std::string>& keys, const std::string& data, bool writeSector0,
-                                             std::function<void(int, int)> mapCb, std::function<void(int, int)> writeCb)
+LibNfc::Utils::ResultBool FreeFareTagClassic::write(const std::vector<std::string>& keys,
+                                                    const std::string& data,
+                                                    bool writeSector0,
+                                                    std::function<void(FreeFareTagClassicMappingProgress)> mapCb,
+                                                    std::function<void(FreeFareTagClassicWriteProgress)> writeCb)
 {
     auto mappedKeysResult = mapKeys(keys, mapCb);
     if (!mappedKeysResult) {