Tracelet Sync: The Network Story

ഡാറ്റ ഒരിക്കലും നിങ്ങളുടെ സെർവറുകളിൽ എത്തുന്നില്ലെങ്കിൽ ലൊക്കേഷൻ ട്രാക്കിംഗ് അർത്ഥമാക്കുന്നില്ല. എലിവേറ്ററുകളിൽ പ്രവേശിക്കുമ്പോഴോ താഴ്‌വരകളിലൂടെ ഡ്രൈവ് ചെയ്യുമ്പോഴോ Wi-Fi-യിൽ നിന്ന് സെല്ലുലാറിലേക്ക് മാറുമ്പോഴോ മൊബൈൽ ഉപകരണങ്ങൾ തുടർച്ചയായി കണക്ഷൻ ഡ്രോപ്പ് ചെയ്യുന്നു. UI ഉണർത്താതെ തന്നെ ഡാറ്റ ഡെലിവറി ഉറപ്പാക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്ന ഒരു ഓഫ്‌ലൈൻ-ആദ്യ ബാറ്ററി-അവബോധ നെറ്റ്‌വർക്കിംഗ് എഞ്ചിനാണ് Tracelet Sync.

ട്രേസ്‌ലെറ്റ് 3.2.0 അപ്‌ഡേറ്റ്: HTTP സമന്വയ ലോജിക് tracelet_sync മൊഡ്യൂളിലേക്ക് നീക്കി. നിങ്ങൾക്ക് നെറ്റ്‌വർക്ക് സിൻക്രൊണൈസേഷൻ ആവശ്യമുണ്ടെങ്കിൽ ഈ മൊഡ്യൂൾ ഉൾപ്പെടുത്തണം.

നെറ്റ്‌വർക്കിലേക്ക് എങ്ങനെ സമന്വയിപ്പിക്കാം

Tracelet Core ലൊക്കേഷനുകൾ ക്യാപ്‌ചർ ചെയ്യുമ്പോൾ, tracelet_sync എന്നത് നിങ്ങളുടെ സെർവറിലേക്ക് അവ എത്തിക്കുന്ന പശ്ചാത്തല HTTP എഞ്ചിനാണ്. ഇത് പ്രവർത്തനക്ഷമമാക്കാൻ, നിങ്ങൾ ട്രാക്കിംഗ് ആരംഭിക്കുന്നതിന് മുമ്പ് TraceletSync.ready() സമാരംഭിക്കുക:


import 'package:tracelet_sync/tracelet_sync.dart';
 
void main() async {
  WidgetsFlutterBinding.ensureInitialized();
 
  // 1. Configure the Sync Engine
  await TraceletSync.ready(SyncConfig(
    url: 'https://your-api.com/locations',
    method: 'POST',
    autoSyncThreshold: 10,       // Sync every 10 locations
    autoSyncDelay: 10000,        // Wait 10s before pushing
    syncInterval: 0,             // (Optional) Seconds between repeating queue flushes; 0 = off
    batchSync: true,             // Send as a JSON array
    maxBatchSize: 250,           // Up to 250 locations per request
    headers: {
      'Authorization': 'Bearer YOUR_TOKEN'
    },
  ));
 
  // 2. Configure and start Tracelet Core as usual
  await Tracelet.ready(Config.balanced());
  await Tracelet.start();
}

കോൺഫിഗർ ചെയ്തുകഴിഞ്ഞാൽ, താഴെയുള്ള എല്ലാ സാഹചര്യങ്ങളും എഞ്ചിൻ സ്വയമേവ കൈകാര്യം ചെയ്യും!

രംഗം 1: മലകയറ്റം

ആശയങ്ങൾ പര്യവേക്ഷണം ചെയ്‌തു: ഓഫ്‌ലൈൻ ക്യൂയിംഗ്, ബാച്ച് സമന്വയം, ഡീബൗൺസിംഗ്

പ്രശ്നം

പർവതങ്ങളിലൂടെയുള്ള 3 മണിക്കൂർ കാൽനടയാത്ര ട്രാക്കുചെയ്യാൻ മാർക്ക് നിങ്ങളുടെ ഫിറ്റ്നസ് ആപ്പ് ഉപയോഗിക്കുന്നു. അദ്ദേഹത്തിന് സീറോ സെല്ലുലാർ സേവനം ഉണ്ട്. നിങ്ങളുടെ ആപ്പ് ഓരോ തവണയും ഒരു HTTP POST ചെയ്യാൻ ശ്രമിച്ചാൽ, അത് പരാജയപ്പെടുകയും സിഗ്നലിനായി തിരയുന്നത് ബാറ്ററി പാഴാക്കുകയും ലൊക്കേഷൻ പോയിൻ്റുകൾ എന്നെന്നേക്കുമായി നഷ്ടപ്പെടുകയും ചെയ്യും. ഒടുവിൽ അവൻ തൻ്റെ കാറിൽ തിരിച്ചെത്തുമ്പോൾ, അവൻ്റെ റൂട്ട് ഒരു ശൂന്യമായ ഭൂപടം പോലെ കാണപ്പെടും.

Tracelet സമന്വയം ഇത് എങ്ങനെ പരിഹരിക്കുന്നു

ഓഫ്‌ലൈൻ SQLite പെർസിസ്റ്റൻസ് (autoSyncThreshold) മാർക്കിന് സിഗ്നൽ ഇല്ലാത്തതിനാൽ, HTTP അഭ്യർത്ഥനകൾ അയയ്‌ക്കാനുള്ള ശ്രമം Tracelet ഉടൻ നിർത്തുന്നു. പകരം, എല്ലാ സ്ഥലങ്ങളും ലോക്കൽ SQLite ഡാറ്റാബേസിൽ സുരക്ഷിതമായി സംഭരിച്ചിരിക്കുന്നു. ഞങ്ങൾ autoSyncThreshold: 100 സജ്ജീകരിച്ചു, അതായത് ഡാറ്റാബേസിൽ കുറഞ്ഞത് 100 പോയിൻ്റുകളെങ്കിലും ക്യൂവിൽ വരുന്നതുവരെ നെറ്റ്‌വർക്ക് റേഡിയോ ഉണർത്താൻ Tracelet ശ്രമിക്കില്ല.
ഡീബൗൺസ്ഡ് സമന്വയിപ്പിക്കൽ (autoSyncDelay) മാർക്ക് ഒടുവിൽ പർവതത്തിലൂടെ ഇറങ്ങി 4G വീണ്ടെടുക്കുമ്പോൾ, അയാൾക്ക് പെട്ടെന്ന് 500 ക്യൂ ലൊക്കേഷനുകൾ ഉണ്ട്. 500 ഉടനടി HTTP അഭ്യർത്ഥനകൾ (അത് അവൻ്റെ ഫോൺ മരവിപ്പിക്കും) ഫയർ ചെയ്യുന്നതിനുപകരം, autoSyncDelay: 10000 Tracelet-നോട് 10 സെക്കൻഡ് കാത്തിരിക്കാൻ പറയുന്നു. ഇത് ഡാറ്റയുടെ ദ്രുതഗതിയിലുള്ള വരവ് ഇല്ലാതാക്കുന്നു, കണക്ഷനെ സ്ഥിരപ്പെടുത്താൻ അനുവദിക്കുന്നു.
ബാച്ച് സമന്വയിപ്പിക്കൽ (batchSync & maxBatchSize) 500 വ്യക്തിഗത POST അഭ്യർത്ഥനകൾക്ക് പകരം, batchSync: true, maxBatchSize: 250 എന്നിവ ലൊക്കേഷനുകളെ രണ്ട് വലിയ JSON അറേകളാക്കി മാറ്റുന്നു. ഇത് ആദ്യത്തെ 250 പോയിൻ്റുകൾ അയയ്ക്കുന്നു, നിങ്ങളുടെ സെർവർ HTTP 200 OK തിരികെ നൽകുന്നതിനായി കാത്തിരിക്കുന്നു, SQLite-ൽ നിന്ന് ആ പോയിൻ്റുകൾ ഇല്ലാതാക്കുന്നു, തുടർന്ന് അടുത്ത ബാച്ച് അയയ്ക്കുന്നു.
ഇൻ്റർവെൽ അധിഷ്ഠിത സമന്വയം (syncInterval) autoSyncDelay പുതിയ ലൊക്കേഷനുകളോട് പ്രതികരിക്കുന്നു. നിങ്ങൾക്ക് സമയാധിഷ്ഠിത ഫ്ലഷ് വേണമെങ്കിൽ - എത്ര പോയിൻ്റുകൾ സമാഹരിച്ചിട്ടുണ്ടെങ്കിലും, ഒരു നിശ്ചിത കാഡൻസിൽ ക്യൂ നിൽക്കുന്നതെന്തും അപ്‌ലോഡ് ചെയ്യുക - ഫ്ലഷുകൾക്കിടയിലുള്ള സെക്കൻഡുകളുടെ എണ്ണത്തിലേക്ക് syncInterval സജ്ജീകരിക്കുക (ഉദാ. syncInterval: 60 മിനിറ്റിൽ ഒരിക്കൽ ഓഫ്‌ലൈൻ ക്യൂ ഫ്ലഷ് ചെയ്യുന്നു). ഇത് ഡീബൗൺസിനൊപ്പം പ്രവർത്തിക്കുകയും സ്ഥിരസ്ഥിതിയായി പ്രവർത്തനരഹിതമാക്കുകയും ചെയ്യുന്നു (0).

സാഹചര്യം 2: കഫേ വൈഫൈയിലേക്ക് കണക്‌റ്റ് ചെയ്യുന്നു

പര്യവേക്ഷണം ചെയ്ത ആശയങ്ങൾ: സെല്ലുലാർ നിയന്ത്രണങ്ങൾ, ഡെൽറ്റ കംപ്രഷൻ

പ്രശ്നം

മാർക്ക് തൻ്റെ കാൽനടയാത്ര പൂർത്തിയാക്കി ഒരു കഫേയിലേക്ക് പോകുന്നു. അവൻ അന്തർദേശീയമായി യാത്ര ചെയ്യുന്നു, അതിനാൽ അവൻ്റെ സെല്ലുലാർ ഡാറ്റ പ്ലാൻ വളരെ ചെലവേറിയതാണ്. നിങ്ങളുടെ ആപ്പ് ലൊക്കേഷൻ JSON ഡാറ്റയുടെ മെഗാബൈറ്റ് ക്യൂ അപ്പ് ചെയ്‌തു, അവൻ്റെ റോമിംഗ് 4G കണക്ഷനിലൂടെ അത് അയയ്‌ക്കുന്നത് അയാൾക്ക് പണച്ചെലവുണ്ടാക്കും.

Tracelet സമന്വയം ഇത് എങ്ങനെ പരിഹരിക്കുന്നു

സെല്ലുലാർ നിയന്ത്രണം (disableAutoSyncOnCellular) disableAutoSyncOnCellular: true സജ്ജീകരിക്കുന്നതിലൂടെ, Mark 4G-ൽ ആയിരിക്കുമ്പോൾ Tracelet സമന്വയ എഞ്ചിനെ പൂർണ്ണമായും തടയുന്നു. ലൊക്കേഷനുകൾ SQLite-ൽ സുരക്ഷിതമാണ്. അവൻ കഫേയുടെ Wi-Fi-യിലേക്ക് കണക്റ്റുചെയ്യുന്ന നിമിഷം, OS Tracelet-നെ ഉണർത്തുന്നു, ഒപ്പം സമന്വയ എഞ്ചിൻ സ്വയമേവ ക്യൂ ഫ്ലഷ് ചെയ്യുന്നു.
ഡെൽറ്റ എൻകോഡിംഗ് കംപ്രഷൻ (enableDeltaCompression) Wi-Fi-യിൽ പോലും, വലിയ JSON അറേകൾ അയയ്‌ക്കുന്നത് മന്ദഗതിയിലാണ്. ബാച്ച് അയയ്‌ക്കുന്നതിന് മുമ്പ് ട്രേസ്‌ലെറ്റ് ഡെൽറ്റ കംപ്രഷൻ പ്രയോഗിക്കുന്നു. മാർക്ക് ഒരു നേർരേഖയിൽ നടന്നാൽ, അവൻ്റെ അക്ഷാംശത്തിൽ വലിയ മാറ്റമുണ്ടായില്ല. ഓരോ പോയിൻ്റിനും പൂർണ്ണ കോർഡിനേറ്റുകൾ അയയ്‌ക്കുന്നതിനുപകരം, ട്രെയ്‌സ്‌ലെറ്റ് ആദ്യത്തെ പോയിൻ്റ് പൂർണ്ണമായി അയയ്‌ക്കുന്നു, തുടർന്ന് തുടർന്നുള്ള പോയിൻ്റുകൾക്കുള്ള വ്യത്യാസം (ഡെൽറ്റ) മാത്രം. deltaCoordinatePrecision: 5 (~1.1 മീറ്റർ വരെ കൃത്യത) ഉപയോഗിച്ച്, ഇത് HTTP പേലോഡ് വലുപ്പം 60% മുതൽ 80% വരെ കുറയ്ക്കുന്നു.

സ്റ്റാൻഡേർഡ് പേലോഡ് (കംപ്രഷൻ ഇല്ല):
```
[
  {"lat": 37.774900, "lng": -122.419400},
  {"lat": 37.774910, "lng": -122.419410},
  {"lat": 37.774920, "lng": -122.419420}
]
```
ഡെൽറ്റ എൻകോഡ് ചെയ്ത പേലോഡ് (നിങ്ങളുടെ സെർവറിന് ലഭിക്കുന്നത്):
```
[
  {"lat": 37.774900, "lng": -122.419400},
  {"dLat": 10, "dLng": 10},
  {"dLat": 10, "dLng": 10}
]
```

രംഗം 3: കാലഹരണപ്പെട്ട സെഷൻ

പര്യവേക്ഷണം ചെയ്‌ത ആശയങ്ങൾ: 401 ആവർത്തനങ്ങൾ, തലയില്ലാത്ത കോൾബാക്കുകൾ, എക്‌സ്‌പോണൻഷ്യൽ ബാക്ക്ഓഫ്

പ്രശ്നം

കാൽനടയാത്രയ്ക്കിടെ മാർക്കിൻ്റെ ഓത്ത് ടോക്കൺ (JWT) കാലഹരണപ്പെട്ടു. Tracelet ഒടുവിൽ നിങ്ങളുടെ സെർവറിലേക്ക് ബാച്ച് സമന്വയിപ്പിക്കാൻ ശ്രമിക്കുമ്പോൾ, നിങ്ങളുടെ API ഒരു HTTP 401 Unauthorized നൽകുന്നു. ഒരു നിഷ്കളങ്കമായ സമന്വയ എഞ്ചിൻ ഒന്നുകിൽ ഡാറ്റ പരാജയപ്പെട്ടുവെന്ന് കരുതി അത് ഇല്ലാതാക്കും, അല്ലെങ്കിൽ 401 സെക്കൻഡിൻ്റെ അനന്തമായ ലൂപ്പിൽ കുടുങ്ങി, ബാറ്ററി ശൂന്യമാക്കും. സ്‌ക്രീൻ ഓഫായി മാർക്കിൻ്റെ ഫോൺ പോക്കറ്റിലുണ്ട്—അവന് ഇപ്പോൾ ലോഗിൻ ചെയ്യാൻ കഴിയില്ല.

Tracelet സമന്വയം ഇത് എങ്ങനെ പരിഹരിക്കുന്നു

ഡൈനാമിക് ഹെഡർ കോൾബാക്കുകൾ Tracelet 401 ലഭിക്കുമ്പോൾ, അത് വീണ്ടും ശ്രമിക്കുന്നതിന് മുമ്പ് ഒരു പുതിയ ടോക്കൺ ലഭ്യമാക്കണം. മുൻവശത്തും പശ്ചാത്തലത്തിലും (തലയില്ലാത്ത) അവസ്ഥകളിൽ ഇത് കൈകാര്യം ചെയ്യാൻ നിങ്ങൾ കോൾബാക്കുകൾ രജിസ്റ്റർ ചെയ്യുന്നു.

ഫോർഗ്രൗണ്ട് കോൾബാക്ക്:
```
tl.Tracelet.setHeadersCallback(() async {
  final newJwt = await AuthAPI.refreshToken();
  return {'Authorization': 'Bearer $newJwt'};
});
```
പശ്ചാത്തലം (തലയില്ലാത്ത) കോൾബാക്ക്: ഇത് നിങ്ങളുടെ UI ഉണർത്താതെ ഒരു ഒറ്റപ്പെട്ട ഡാർട്ട് എഞ്ചിനിൽ പ്രവർത്തിക്കുന്നു, ഉപയോക്താവ് ആപ്പ് നിർബന്ധിതമായി ഉപേക്ഷിച്ചാലും സമന്വയം പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.
```
@pragma('vm:entry-point')
void headlessHeadersCallback(tl.HeadlessEvent event) async {
  final newJwt = await AuthAPI.refreshToken();
  tl.Tracelet.setDynamicHeaders({'Authorization': 'Bearer $newJwt'});
}
 
// Register it before runApp()
tl.Tracelet.registerHeadlessHeadersCallback(headlessHeadersCallback);
```
എക്‌സ്‌പോണൻഷ്യൽ ബാക്ക്ഓഫ് (maxRetries & retryBackoffCap) നിങ്ങളുടെ ഓത്ത് സെർവർ പ്രവർത്തനരഹിതമാവുകയും 503 നൽകുകയും ചെയ്താലോ? Tracelet ഇത് ഭംഗിയായി കൈകാര്യം ചെയ്യുന്നു. അത് വീണ്ടും ശ്രമിക്കാൻ ശ്രമിക്കുന്നു. അത് പരാജയപ്പെടുന്നു. ഇത് 1 സെക്കൻഡ് (retryBackoffBase), തുടർന്ന് 2 സെക്കൻഡ്, തുടർന്ന് 4 സെക്കൻഡ് കാത്തിരിക്കുന്നു. എക്‌സ്‌പോണൻഷ്യൽ ബാക്ക്ഓഫ് 60 സെക്കൻഡിൽ (retryBackoffCap) പരിമിതപ്പെടുത്തിയിരിക്കുന്നു. 3 ശ്രമങ്ങൾക്ക് ശേഷം (maxRetries), അത് പൂർണ്ണമായും ഉപേക്ഷിക്കുന്നു, നാളെ വീണ്ടും ശ്രമിക്കുന്നതിനായി ഡാറ്റ സുരക്ഷിതമായി SQLite-ൽ വിടുന്നു.

സാഹചര്യം 4: കസ്റ്റം സെർവർ സ്കീമ

ആശയങ്ങൾ പര്യവേക്ഷണം ചെയ്‌തു: ഇഷ്‌ടാനുസൃത സമന്വയ ബോഡി ബിൽഡർമാർ, സ്കീമ മാപ്പിംഗ്

പ്രശ്നം

ലൊക്കേഷൻ ഡാറ്റ വളരെ നിർദ്ദിഷ്ടവും നിലവാരമില്ലാത്തതുമായ ഫോർമാറ്റിൽ പ്രതീക്ഷിക്കുന്ന ഒരു ലെഗസി ബാക്കെൻഡ് മാർക്കിൻ്റെ കമ്പനിക്കുണ്ട്. Tracelet-ൻ്റെ ഡിഫോൾട്ട് JSON പേലോഡ് അവരുടെ സെർവറിന് ആവശ്യമായ സ്കീമയുമായി പൊരുത്തപ്പെടുന്നില്ല, മാത്രമല്ല ഈ ആപ്പിന് വേണ്ടി മാത്രം ബാക്കെൻഡ് API മാറ്റാൻ അവർക്ക് കഴിയില്ല.

Tracelet സമന്വയം ഇത് എങ്ങനെ പരിഹരിക്കുന്നു

ഇഷ്‌ടാനുസൃത സമന്വയ ബോഡി ബിൽഡർ (setSyncBodyBuilder) ഡിഫോൾട്ട് JSON റാപ്പർ ഉപയോഗിക്കുന്നതിനുപകരം, നെറ്റ്‌വർക്കിലൂടെ അയയ്‌ക്കുന്നതിന് മുമ്പായി ലൊക്കേഷനുകളുടെ ബാച്ച് തടസ്സപ്പെടുത്താൻ Tracelet നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് നിങ്ങളുടെ സെർവർ ആഗ്രഹിക്കുന്ന ഏത് രൂപത്തിലും മാപ്പ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ട്രേസ്‌ലെറ്റ് 3.2.8 മുതൽ, ഈ ബിൽഡർക്ക് കൈമാറിയ ലൊക്കേഷനുകൾ ശക്തമായ ഒരു നെസ്റ്റഡ് സ്‌കീമ ഉപയോഗിക്കുന്നു (ഇവിടെ കോർഡിനേറ്റുകൾ സുരക്ഷിതമായി coords എന്നതിന് കീഴിലും ആക്‌റ്റിവിറ്റി ഡാറ്റ activity എന്നതിന് കീഴിലും ഗ്രൂപ്പുചെയ്യുന്നു).
```
Tracelet.setSyncBodyBuilder((context) async {
  // Map Tracelet's nested schema to your legacy server's flat schema
  final mappedPoints = context.locations.map((loc) {
    final coords = loc['coords'] as Map;
    final activity = loc['activity'] as Map;
    
    return {
      'lat': coords['latitude'],
      'lng': coords['longitude'],
      'time': loc['timestamp'],
      'moving': loc['is_moving'],
      'action': activity['type'],
    };
  }).toList();
 
  // Return the exact JSON structure your server expects
  return {
    'device_id': myDeviceId,
    'payload': mappedPoints,
  };
});
```
തലയില്ലാത്ത വധശിക്ഷ ടോക്കൺ പുതുക്കലുകൾ പോലെ, ഈ ഇഷ്‌ടാനുസൃത ബോഡി ബിൽഡിംഗും registerHeadlessSyncBodyBuilder() വഴി പശ്ചാത്തലത്തിൽ പൂർണ്ണമായും തലയില്ലാതെ നടപ്പിലാക്കാൻ കഴിയും, ആപ്പ് പൂർണ്ണമായും അവസാനിപ്പിച്ചാലും നിങ്ങളുടെ ഇഷ്‌ടാനുസൃത സ്‌കീമ നിർമ്മിച്ച് അയയ്‌ക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.

രംഗം 5: ഡെലിവറി ഡ്രൈവർ

പര്യവേക്ഷണം ചെയ്‌ത ആശയങ്ങൾ: റൂട്ട് സന്ദർഭവും ബിസിനസ് ലോജിക് ഇഞ്ചക്ഷൻ

പ്രശ്നം

നിങ്ങളുടെ ബാക്കെൻഡിന് ആയിരക്കണക്കിന് റോ കോർഡിനേറ്റുകൾ ലഭിക്കുന്നു. എന്നാൽ ഒരു കോർഡിനേറ്റ് മാത്രം ഉപയോക്താവ് അവിടെ ഉണ്ടായിരുന്നത് എന്തുകൊണ്ട് നിങ്ങളോട് പറയുന്നില്ല. ഡ്രൈവർ ഡെലിവറി ടാസ്ക്കിൽ ആയിരുന്നോ? ഏത് ഓർഡറാണ് അവർ വിതരണം ചെയ്തത്? പശ്ചാത്തല ലൊക്കേഷൻ പേലോഡിലേക്ക് നേരിട്ട് ബിസിനസ്സ് ലോജിക് അറ്റാച്ചുചെയ്യാൻ നിങ്ങൾക്ക് ഒരു മാർഗം ആവശ്യമാണ്, അതിനാൽ നിങ്ങളുടെ ഡാറ്റാബേസിൽ അത് എളുപ്പത്തിൽ അന്വേഷിക്കാനാകും.

Tracelet സമന്വയം ഇത് എങ്ങനെ പരിഹരിക്കുന്നു

റൂട്ട് സന്ദർഭം സജ്ജീകരിക്കുന്നു നിങ്ങൾക്ക് Tracelet-ലേക്ക് ഇഷ്‌ടാനുസൃത മെറ്റാഡാറ്റ കുത്തിവയ്ക്കാൻ കഴിയും. നിങ്ങൾ setRouteContext() എന്ന് വിളിച്ചതിന് ശേഷം റെക്കോർഡുചെയ്‌ത എല്ലാ ലൊക്കേഷനും ആന്തരിക SQLite ഡാറ്റാബേസിൽ ഈ ഡാറ്റയുമായി സ്വയമേവ ടാഗ് ചെയ്യപ്പെടും.
```
await tl.Tracelet.setRouteContext(
  const tl.RouteContext(
    taskId: 'delivery-1234',
    driverId: 'john_doe',
    custom: {'shift_id': 'morning-shift-001'},
  ),
);
```
ഫലമായ JSON പേലോഡ് Tracelet നിങ്ങളുടെ ബാക്കെൻഡുമായി സമന്വയിപ്പിക്കുമ്പോൾ, അറേയിലെ എല്ലാ ലൊക്കേഷനും context ഒബ്‌ജക്റ്റ് ഉൾപ്പെടും, ഈ ലൊക്കേഷൻ ഏത് ടാസ്‌ക്കിൻ്റേതാണെന്ന് കൃത്യമായി അറിയാമെന്ന് നിങ്ങളുടെ ബാക്കെൻഡിന് ഉറപ്പുനൽകുന്നു.
```
{
  "locations": [
    {
      "coords": { "latitude": 37.7749, "longitude": -122.4194 },
      "battery": { "level": 0.85, "isCharging": true },
      "extras": { "your_custom_key": "your_value" },
      "context": {
        "taskId": "delivery-1234",
        "driverId": "john_doe",
        "custom": {
          "shift_id": "morning-shift-001"
        }
      }
    }
  ]
}
```

ബാറ്ററി സ്റ്റേറ്റ് ട്രാക്കിംഗ്

ഒരു ലൊക്കേഷൻ റെക്കോർഡ് ചെയ്‌ത് മണിക്കൂറുകൾക്ക് ശേഷം ഉപകരണങ്ങൾ സമന്വയിപ്പിച്ചേക്കാവുന്ന പരുക്കൻ, ഓഫ്‌ലൈൻ പരിതസ്ഥിതികൾക്കായാണ് ട്രേസ്‌ലെറ്റ് രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നത്. ഫീൽഡിലെ ഉപകരണത്തിൻ്റെ ആരോഗ്യം മനസ്സിലാക്കാൻ നിങ്ങളെ സഹായിക്കുന്നതിന്, ഓരോ ലൊക്കേഷനും റെക്കോർഡ് ചെയ്യപ്പെടുന്ന നിമിഷത്തിൽ Tracelet യാന്ത്രികമായി കൃത്യമായ ബാറ്ററി നില പിടിച്ചെടുക്കുന്നു.

ഇതിന് പൂജ്യം കോൺഫിഗറേഷൻ ആവശ്യമാണ്:

എഞ്ചിൻ level (ഉദാ. 85% ന് 0.85), isCharging അവസ്ഥ എന്നിവ ക്യാപ്‌ചർ ചെയ്യുന്നു.
GPS കോർഡിനേറ്റുകൾക്കൊപ്പം ഓഫ്‌ലൈൻ SQLite ഡാറ്റാബേസിൽ ഈ അവസ്ഥ സുരക്ഷിതമായി സംരക്ഷിച്ചിരിക്കുന്നു.
ഉപകരണം ഓൺലൈനിൽ തിരികെ വരുമ്പോൾ, സമന്വയ എഞ്ചിൻ നിലവിലെ ബാറ്ററി നിലയല്ല, കൃത്യമായ ചരിത്ര ബാറ്ററി നിലയാണ് കൈമാറുന്നത്.

ഇത് നിങ്ങളുടെ ബാക്കെൻഡിനെ ഒരു റൂട്ടിലെ ബാറ്ററി ചോർച്ച കൃത്യമായി ദൃശ്യമാക്കാൻ അനുവദിക്കുന്നു, അല്ലെങ്കിൽ ഷിഫ്റ്റുകളിൽ ഡ്രൈവർമാർ അവരുടെ ഉപകരണങ്ങൾ തുടർച്ചയായി അൺപ്ലഗ് ചെയ്യുന്നുണ്ടോ എന്ന് തിരിച്ചറിയുക.

സന്ദർഭം മായ്‌ക്കുന്നു ഡ്രൈവർ ഡെലിവറി പൂർത്തിയാക്കുമ്പോൾ, സന്ദർഭം വ്യക്തമാക്കുക. തുടർന്നുള്ള ലൊക്കേഷനുകൾ ഇനി ടാഗ് ചെയ്യപ്പെടില്ല.
```
await tl.Tracelet.clearRouteContext();
```
സമന്വയിപ്പിക്കുന്നതിന് മുമ്പ് ഈ സന്ദർഭത്തെ അടിസ്ഥാനമാക്കി നിങ്ങൾക്ക് ആന്തരിക SQLite ഡാറ്റാബേസിൽ പോലും അന്വേഷിക്കാവുന്നതാണ്:
```
// Get all locations belonging to a specific delivery task
final locations = await tl.Tracelet.getLocations(
  tl.SQLQuery(where: "context_task_id = 'delivery-1234'")
);
```

രംഗം 6: ടെലിമാറ്റിക്സ് ബാക്കെൻഡ്

ആശയങ്ങൾ പര്യവേക്ഷണം ചെയ്‌തു: ടെലിമാറ്റിക്‌സ് സമന്വയം, ഇവൻ്റ് പേലോഡ് സ്കീമ, പ്രത്യേക അന്തിമ പോയിൻ്റുകൾ

പ്രശ്നം

നിങ്ങളുടെ ആപ്പ് ഇതിനകം തന്നെ ലൊക്കേഷനുകൾ സ്ട്രീം ചെയ്യുന്നു. ഇപ്പോൾ ഉൽപ്പന്ന ടീമിന് ഡ്രൈവിംഗ് പെരുമാറ്റവും വേണം - കഠിനമായ ബ്രേക്കിംഗ്, കഠിനമായ ത്വരണം, വളവുകൾ, വേഗത - ഓരോ ഡ്രൈവർക്കും സ്കോർ. ഈ സംഭവങ്ങൾ പശ്ചാത്തലത്തിൽ റെക്കോർഡ് ചെയ്യപ്പെടുന്നു, സാധാരണയായി ഫോണിന് സിഗ്നൽ ഇല്ലാതിരിക്കുകയും ആരും സ്ക്രീനിൽ നോക്കാതിരിക്കുകയും ചെയ്യുന്നു. അവ നിങ്ങൾക്ക് നഷ്ടപ്പെടുത്താൻ താങ്ങാനാകുന്ന വരികളാണ്, കൂടാതെ “വീണ്ടും ശ്രമിക്കുക” ടാപ്പുചെയ്യാൻ ഒരു ഉപയോക്താവുമില്ല.

Tracelet സമന്വയം ഇത് എങ്ങനെ പരിഹരിക്കുന്നു

syncTelematics ഉപയോഗിച്ച് തിരഞ്ഞെടുക്കുക ഡ്രൈവിംഗ്, ഇംപാക്റ്റ് ഇവൻ്റുകൾ എല്ലായ്പ്പോഴും പ്രാദേശികമായി നിലനിൽക്കും - അതാണ് Tracelet.getTelematicsEvents() വായിക്കുന്നത്. അവ അപ്‌ലോഡ് ചെയ്യുന്നത് ഡിഫോൾട്ടായി ഓപ്റ്റ്-ഇൻ ഓഫാണ്, അതിനാൽ നിലവിലുള്ള ഒരു ഇൻ്റഗ്രേഷൻ്റെ പേലോഡ് അതിന് താഴെ ഒരിക്കലും മാറില്ല.
```
http: tl.HttpConfig(
  url: 'https://api.example.com/locations',
  method: tl.HttpMethod.post,
  autoSync: true,
  batchSync: true,
  maxBatchSize: 50,
  syncTelematics: true, // ← upload driving/impact events too
),
```

ഒരു അഭ്യർത്ഥന, ഒരു റേഡിയോ വേക്ക് (ഡിഫോൾട്ട്) syncTelematics: true കൂടാതെ telematicsUrl ഇല്ലാതെ, ഇവൻ്റുകൾ നിങ്ങളുടെ location അറേയ്‌ക്ക് അടുത്തായി റൂട്ട്-ലെവൽ telematics അറേ ആയി ലൊക്കേഷൻ അഭ്യർത്ഥന നടത്തുന്നു. ഒരു ഫ്ലഷ് ഒരൊറ്റ പോസ്‌റ്റിൽ തുടരുന്നു - പശ്ചാത്തല റേഡിയോ ഒരു തവണ ഉണരും, രണ്ടുതവണയല്ല.


{
  "location": [ /* ...your usual location records... */ ],
  "telematics": [
    {
      "id": 412,
      "event_type": "harsh_braking",
      "severity": 0.82,
      "speed": 18.4,
      "value": 0.47,
      "latitude": 24.8607,
      "longitude": 67.0011,
      "timestamp": "2026-08-20T09:14:02.000Z",
      "synced": false
    }
  ]
}

ഫീൽഡ്	തരം	അർത്ഥം
`id`	നോട്ട്രാൻസ്1ലേറ്റ്	പ്രാദേശിക SQLite വരിയുടെ പ്രാഥമിക കീ. ഓരോ ഇൻസ്റ്റാളിലും ആരോഹണം - നിങ്ങളുടെ വശത്ത് ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യാൻ ഇത് ഉപയോഗിക്കുക.
`event_type`	നോട്ട്രാൻസ്1ലേറ്റ്	`harsh_braking`, `harsh_acceleration`, `harsh_cornering`, `speeding`, അല്ലെങ്കിൽ ഒരു ഇംപാക്ട് തരം (`potential_crash`, `crash`, `potential_fall`, `fall`).
`severity`	നോട്ട്രാൻസ്1ലേറ്റ്	നോർമലൈസ്ഡ് `0.0–1.0` - ഇവൻ്റ് കണ്ടെത്തൽ പരിധി എത്ര ദൂരെയാണ്.
`speed`	നോട്ട്രാൻസ്1ലേറ്റ്	m/s എന്നതിൽ ഇവൻ്റിലെ വേഗത. ഒരു ആഘാതത്തിനായി, അകത്തേക്ക് പോകുന്ന വേഗത.
`value`	നോട്ട്രാൻസ്1ലേറ്റ്	`severity`-ന് പിന്നിലെ ഭൌതിക മാഗ്നിറ്റ്യൂഡ്: g കഠിനമായ സംഭവങ്ങൾക്കും ആഘാതങ്ങൾക്കും, km/h പരിധിക്ക് മുകളിൽ വേഗത.
`latitude` / `longitude`	`double`	എവിടെയാണ് സംഭവിച്ചത്.
`timestamp`	നോട്ട്രാൻസ്1ലേറ്റ്	ISO-8601.
`synced`	നോട്ട്രാൻസ്1ലേറ്റ്	വരി വായിച്ചപ്പോഴുള്ള അവസ്ഥ — വയറിലെ ഒരു ഇവൻ്റിന് എല്ലായ്പ്പോഴും `false`.

speed ഉം value ഉം 3.8.3-ൽ നിലനിൽക്കുന്ന വരിയിൽ ചേർന്നു. രണ്ടിനും 0 എന്ന പഴയ ഇൻസ്റ്റാളേഷൻ റിപ്പോർട്ട് റെക്കോർഡ് ചെയ്‌ത ഇവൻ്റുകൾ: നിരകൾ അസാധുവാണ്, അതിനാൽ അപ്‌ഗ്രേഡ് ചെയ്‌ത ഡാറ്റാബേസിന് യഥാർത്ഥ പൂജ്യത്തിൽ നിന്ന് പഴയ വരി പറയാൻ കഴിയില്ല.

ബാച്ചിംഗ്, വീണ്ടും ശ്രമിക്കുക 250 സമന്വയിപ്പിക്കാത്ത ഇവൻ്റുകൾ വരെ ഓരോ ഫ്ലഷിനും പോകുന്നു, ഏറ്റവും പഴയത് ആദ്യം. ആ ബൗണ്ട് maxBatchSize-ൽ നിന്ന് സ്വതന്ത്രമാണ്, അത് ലൊക്കേഷൻ ബാച്ചിൻ്റെ മാത്രം വലുപ്പം നൽകുന്നു.

ഇവൻ്റുകൾ സമന്വയിപ്പിച്ചതായി അടയാളപ്പെടുത്തുന്നു അവ നടത്തിയ അഭ്യർത്ഥന വിജയിക്കുമ്പോൾ മാത്രം. പരാജയപ്പെട്ട ഒരു പോസ്റ്റ് - ഓഫ്‌ലൈൻ, 401, 503 - അവരെ ലൊക്കേഷനുകൾ പോലെ തന്നെ ഉപേക്ഷിക്കുന്നതിനുപകരം അടുത്ത ശ്രമത്തിനായി ക്യൂവിൽ നിർത്തുന്നു.

അവ മാർക്ക് ചെയ്‌തിരിക്കുന്നു, ഇല്ലാതാക്കിയിട്ടില്ല എന്നത് ശ്രദ്ധിക്കുക: അപ്‌ലോഡ് ചെയ്‌ത ഒരു ഇവൻ്റ് Tracelet.getTelematicsEvents()-ന് ദൃശ്യമായി നിലനിൽക്കും, അതിനാൽ നിങ്ങളുടെ ആപ്പിന് തുടർന്നും ഡ്രൈവർക്ക് അവരുടെ സ്വന്തം ചരിത്രം കാണിക്കാനാകും. സമന്വയിപ്പിച്ച വാൽ ഏറ്റവും പുതിയ 1000 വരികളിലേക്ക് ട്രിം ചെയ്‌തിരിക്കുന്നതിനാൽ പട്ടിക എന്നെന്നേക്കുമായി വളരാൻ കഴിയില്ല. സമന്വയിപ്പിക്കാത്ത വരികൾ ഒരിക്കലും ട്രിം ചെയ്യില്ല.
ഒരു പ്രത്യേക എൻഡ് പോയിൻ്റ് (telematicsUrl) ലൊക്കേഷനുകളല്ലാതെ മറ്റെവിടെയെങ്കിലും ഇവൻ്റുകൾ ഡ്രൈവ് ചെയ്യുന്നതാണ് നിങ്ങളുടെ ബാക്കെൻഡ് റൂട്ടെങ്കിൽ, telematicsUrl സജ്ജീകരിക്കുക. ലൊക്കേഷൻ പേലോഡ് റൈഡ് ചെയ്യുന്നതിനുപകരം, ഇവൻ്റുകൾ അവരുടെ സ്വന്തം പോസ്‌റ്റിൽ - ബോഡി {"telematics": [...]}-ൽ, അതേ തലക്കെട്ടുകൾ, ടൈംഔട്ടുകൾ, വീണ്ടും ശ്രമിക്കൽ, url പോലെയുള്ള SSL പിൻ ചെയ്യൽ എന്നിവ ഉപയോഗിച്ച് യാത്ര ചെയ്യുന്നു.
```
http: tl.HttpConfig(
  url: 'https://api.example.com/locations',
  syncTelematics: true,
  telematicsUrl: 'https://api.example.com/telematics',
),
```
ബാറ്ററിയുടെ വില കാണുന്നതിനേക്കാൾ ചെറുതാണ്: രണ്ട് അഭ്യർത്ഥനകളും ഒരേ ഫ്ലഷിനുള്ളിൽ തിരികെ പോകുന്നു, അതിനാൽ രണ്ടാമത്തേത് ഇതിനകം ഉണർന്നിരിക്കുന്ന ഒരു റേഡിയോ വീണ്ടും ഉപയോഗിക്കുന്നു. ബാറ്ററി കളയുന്നത് അതിൻ്റെ സ്വന്തം ഷെഡ്യൂളിൽ പ്രവർത്തിക്കുന്ന രണ്ടാമത്തെ അപ്‌ലോഡറാണ്, അതല്ല ഇത്. ഒരു ടെലിമാറ്റിക്‌സ് മാത്രമുള്ള ഫ്ലഷ് (ഇവൻ്റുകൾ ക്യൂവിലാണ്, പുതിയ ലൊക്കേഷനുകളൊന്നുമില്ല) ശൂന്യമായ ഒരെണ്ണം അയയ്‌ക്കുന്നതിനുപകരം POST എന്ന സ്ഥാനം പൂർണ്ണമായും ഒഴിവാക്കുന്നു.

പിന്നീട് അറ്റാച്ച് ചെയ്‌ത പാതയിലേക്ക് മടങ്ങുന്നതിന്, null-ന് പകരം ശൂന്യമായ സ്ട്രിംഗ് കടന്നുപോകുക - കോൺഫിഗറേഷൻ ലയിപ്പിച്ചിരിക്കുന്നു, പകരം വയ്ക്കില്ല, അതിനാൽ null എന്നാൽ “ഇതിനകം ഉള്ളത് ഉപേക്ഷിക്കുക” എന്നാണ് അർത്ഥമാക്കുന്നത്.
കസ്റ്റം ബോഡി ബിൽഡർമാർ അവരെയും കാണുന്നു നിങ്ങൾ സ്വയം ബോഡി രൂപപ്പെടുത്തുകയാണെങ്കിൽ, മുകളിലെ പട്ടികയിലെ അതേ ഫീൽഡ് നാമങ്ങൾ ഉപയോഗിച്ച്, സമന്വയിപ്പിക്കാത്ത ഇവൻ്റുകൾ ലൊക്കേഷനുകൾക്കൊപ്പം സന്ദർഭത്തിൽ എത്തിച്ചേരും:
```
Tracelet.setSyncBodyBuilder((context) async {
  return {
    'points': context.locations,
    'events': context.telematics, // driving/impact events
  };
});
```
syncTelematics പ്രവർത്തനക്ഷമമാക്കിയിട്ടില്ലെങ്കിൽ context.telematics ശൂന്യമാണ്.

ട്രിപ്പുകൾ തുടരുകയോ സമന്വയിപ്പിക്കുകയോ ചെയ്യുന്നില്ല. Tracelet.onTrip() നിങ്ങളുടെ ഡാർട്ട് കോൾബാക്കിലേക്ക് പൂർത്തിയാക്കിയ ട്രിപ്പ് ഡെലിവറി ചെയ്യുകയാണ് SDK-ൽ നിന്ന് ഒരു യാത്ര പുറപ്പെടുന്ന ഏക മാർഗം: ട്രിപ്പ് അവസ്ഥ മെമ്മറിയിൽ സൂക്ഷിക്കുന്നു, ഒരിക്കലും SQLite-ൽ എഴുതിയിട്ടില്ല, ഒരു HTTP എൻഡ്‌പോയിൻ്റിലേക്ക് ഒരിക്കലും അയച്ചിട്ടില്ല. start() എന്ന് വിളിക്കുന്ന ഐസൊലേറ്റ് ട്രിപ്പ് അവസാനിക്കുന്നതിന് മുമ്പ് ഇല്ലാതായാൽ, ഒരു ട്രിപ്പ് ഇവൻ്റുകളൊന്നും നിർമ്മിക്കപ്പെടുന്നില്ല - ഓഫ്‌ലൈനിൽ ഒന്ന് നഷ്‌ടപ്പെടാനുള്ള ഒരേയൊരു മാർഗ്ഗം മാത്രമല്ല. ട്രിപ്പ് പെർസിസ്റ്റൻസ് ഷിപ്പ് ആകുന്നത് വരെ, നിങ്ങൾക്ക് അതിജീവിക്കാൻ ആവശ്യമെങ്കിൽ onTrip() എന്നതിനുള്ളിൽ തന്നെ യാത്ര ലാഭിക്കുക. #356 കാണുക.