Mobile App Development for RFID Inventory: EPC Deduplication & Offline Sync

Standard barcodes require line-of-sight and piece-by-piece scanning—inefficient for mass inventory. RFID lets you read 200 tags in three seconds by just walking along a shelf. We develop mobile apps that ingest a stream of EPC codes without loss, deduplicate them, and reconcile against the expected list—all in real time, even without internet. Our experience: 5 years in mobile development, over 30 projects in logistics and inventory.

For example, in a warehouse with metal shelving, UHF tags often fail to read due to reflections. We tune reader parameters: power, polarization, filters. In one project, we reduced miss rates from 15% to 2% by selecting antennas and configuring settings. This is especially important for metal surfaces where standard settings fail.

Problems We Solve

Duplicate reads—a single tag can be read 50+ times per session. Fast deduplication without UI blocking is needed. Offline mode—warehouses often lack Wi-Fi. The database must be local with later synchronization. Discrepancies—some tags may not be read due to damage or poor placement. We explicitly show found, missing, and extra items. This is critical for warehouses with metal shelves where UHF tags perform worse.

RFID scanning is 100x faster than manual entry or barcodes when checking hundreds of items. But without proper data handling, this advantage is lost.

How to Deduplicate EPC Tags Without Loss

The inventory session is a state machine with transitions: IDLE -> SCANNING -> PROCESSING -> COMPLETED, with pause capability. For each tag read, we update a MutableStateFlow with deduplication by EPC:

class InventorySession(private val expectedItems: List<InventoryItem>) { private val _scannedEpcs = MutableStateFlow<Set<String>>(emptySet()) val scannedEpcs: StateFlow<Set<String>> = _scannedEpcs.asStateFlow() val matchedItems = scannedEpcs.map { epcs -> expectedItems.filter { it.epc in epcs } }.stateIn(scope, SharingStarted.Eagerly, emptyList()) val missingItems = scannedEpcs.map { epcs -> expectedItems.filter { it.epc !in epcs } }.stateIn(scope, SharingStarted.Eagerly, emptyList()) val unexpectedEpcs = scannedEpcs.map { epcs -> val knownEpcs = expectedItems.map { it.epc }.toSet() epcs.filter { it !in knownEpcs } }.stateIn(scope, SharingStarted.Eagerly, emptyList()) fun onTagRead(epc: String) { _scannedEpcs.update { current -> current + epc } } fun reset() { _scannedEpcs.value = emptySet() } } 

Set<String> provides automatic deduplication. One EPC may arrive 50+ times, but the Set stores it once. Derived states (found, missing, extra) are computed reactively via map.

Why Offline Synchronization Is Critical for Warehouses

We ensure the app works without network. A local Room DB stores the expected list and results:

@Entity(tableName = "inventory_sessions") data class InventorySessionEntity( @PrimaryKey val sessionId: String, val locationId: String, val startedAt: Long, val completedAt: Long?, val status: String // "in_progress", "completed", "synced" ) @Entity(tableName = "scanned_tags") data class ScannedTagEntity( @PrimaryKey val epc: String, val sessionId: String, val firstSeenAt: Long, val readCount: Int ) 

readCount is the number of reads for a single tag per session. Anomalously low counts (1–2) when neighboring tags were read 20+ times indicate poor physical placement or damage—a useful QA metric.

After session completion, synchronization via WorkManager when network becomes available:

val syncRequest = OneTimeWorkRequestBuilder<InventorySyncWorker>() .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build()) .setInputData(workDataOf("session_id" to sessionId)) .build() workManager.enqueueUniqueWork("sync_$sessionId", ExistingWorkPolicy.KEEP, syncRequest) 

How to Display Results in Real Time

LazyColumn with key(item.epc)—animated addition of found items:

@Composable fun InventoryResultsScreen(session: InventorySession) { val matched by session.matchedItems.collectAsState() val missing by session.missingItems.collectAsState() val scanned by session.scannedEpcs.collectAsState() Column { LinearProgressIndicator( progress = { if (session.expectedItems.isEmpty()) 0f else matched.size.toFloat() / session.expectedItems.size } ) Text("Found: ${matched.size}/${session.expectedItems.size}") LazyColumn { items(matched, key = { it.epc }) { item -> InventoryItemRow(item = item, status = ItemStatus.FOUND) } items(missing, key = { it.epc }) { item -> InventoryItemRow(item = item, status = ItemStatus.MISSING) } } } } 

GS1 EPC Decoding

EPC is not just a hex string. A structured code like urn:epc:id:sgtin:0614141.107346.2017 contains company, item reference, and serial number. Decoding via SGTIN-96:

fun decodeSgtin96(epc: String): Sgtin96? { val bytes = epc.chunked(2).map { it.toInt(16) }.toByteArray() val bits = BigInteger(1, bytes) val header = bits.shiftRight(88).and(BigInteger.valueOf(0xFF)).toInt() if (header != 0x30) return null val filter = bits.shiftRight(85).and(BigInteger.valueOf(0x07)).toInt() val partition = bits.shiftRight(82).and(BigInteger.valueOf(0x07)).toInt() // further parsing per partition table }