Start here15 min
Barcode scanner integration
Build one scanner boundary, normalize wedge, intent or direct results, and close every session cleanly.
- Barcode / scanner
- Beginner
- Steps
- Validation
Developer Wiki / Getting started
Build the first working integration before you build the whole platform.
Short, practical guides for software teams connecting existing applications to rugged Android handhelds. Start with a small capture flow, keep device APIs behind an adapter, and validate the exact hardware and deployment configuration before a rollout.
Device-specific SDK downloads remain controlled until release rights and test scope are recorded.
interface CapturePort {
fun start()
fun stop()
fun setListener(listener)
}
class CaptureAdapter(
private val device: CapturePort,
) {
fun begin(onCapture) {
device.setListener(onCapture)
device.start()
}
} One boundary. Many device implementations.
A simple learning path
Three steps from first scan to deployment evidence.
Each guide answers one engineering question and ends with a check you can run on the target configuration before an integration review.
01
Start with the workflow
Name the job, capture method, device model and expected output before touching a vendor API.
Open step 02Build one adapter
Keep scanner, printer and key APIs behind a small boundary so the app remains testable.
Open step 03Validate on hardware
Record OS, firmware, SDK, configuration and failure behavior before volume deployment.
Open stepGuides
Start small. Keep the device boundary clear.
The first release focuses on workflows developers can reproduce quickly. Advanced device modules stay clearly scoped.
Start here10 min
Device readiness checklist
Turn a vague “Android device supported” claim into a configuration record that another engineer can reproduce.
- Compatibility baseline
- Beginner
- Steps
- Validation
Core pattern12 min
Test without a device
Use a fake capture port to verify inventory and receiving rules in CI before a physical handheld is available.
- Test adapter
- Beginner
- Steps
- Validation
Core pattern15 min
Printer workflow basics
Render a bounded page, serialize printer work and make paper, heat, voltage and busy states visible.
- Printer
- Intermediate
- Steps
- Validation
Core pattern12 min
Hardware key mapping
Inspect a physical key, preserve the original mapping and provide a reliable restore path before changing behavior.
- Hardware key mapping
- Intermediate
- Steps
- Validation
Review requiredControlled
Card and secure modules
Separate ICC, PICC, magnetic-stripe, PIN and secure-element work from ordinary application code and logs.
- Cards / secure operations
- Advanced
- Steps
- Validation
Core pattern18 min
Device capability and deployment controls
Create a read-only device snapshot, separate privileged operations, and make every deployment change reversible.
- Device capability and deployment controls
- Intermediate
- Steps
- Validation
Developer resources / SDK and source
SDK packages, practical demos and source downloads in one place.
RuggedLayer-hosted packages include a version, size and SHA-256. Public GitHub projects download from their original repository so developers can inspect the source and license history.
Ready to download
RuggedLayer / starter source
Capture adapter starter
A small original source file for isolating scanner work from application business rules. It contains no vendor SDK, binary or device claim.
- Version
- 0.1.0
- Platform
- Kotlin / Android-neutral
- Scope
- CaptureEvent, CapturePort, workflow lifecycle and a fake adapter
- License
- MIT
- Size
- 1.7 KB
- SHA-256
- ee5e2bff6d7d4eb751d390581e9ffc2d4208ee4e098c1d8d694a43c887276f31
Original RuggedLayer source; reviewed 2026-08-03
SDK package download
UROVO / sdk
UROVO Android SDK and samples
A RuggedLayer-hosted UROVO development package for scanner, device, printer, key mapping, card and secure-module integration. Local machine settings and signing materials are excluded.
- Version
- v4.1.0326
- Platform
- Android / Java
- Scope
- API Reference, platform SDK JAR, ScanManager, DeviceManager and terminal sample projects
- License
- UROVO public SDK distribution; no SPDX identifier
- Size
- 4.1 MB
- SHA-256
- 833b002160a4145905e0c0e794b9669def41778cd930e34b559a4ddad9a3e244
Public UROVO package; RuggedLayer distribution approved 2026-08-03
Integration demo download
RuggedLayer / UROVO / integration demo
UROVO ScanManager Kotlin demo
An original adapter and step-by-step README that shows how to connect the UROVO ScanManager API without leaking device calls into application business logic.
- Version
- 0.1.0
- Platform
- Kotlin / Android
- Scope
- Scanner open, Intent output, result normalization, software trigger and lifecycle cleanup
- License
- MIT
- Size
- 3.4 KB
- SHA-256
- 9a4c7a384ea5441e4b0df24ef23f0175efe2ced709f6c77aa1c55b583dbc1a49
Original RuggedLayer code reviewed against UROVO SDK v4.1.0326
Integration demo download
RuggedLayer / integration demo
RFID session and fake-reader demo
A vendor-neutral inventory pattern that lets developers test RFID workflow rules before binding an approved UROVO, SEUIC or other native reader SDK.
- Version
- 0.1.0
- Platform
- Kotlin / Android-neutral
- Scope
- RfidPort, TagRead, session lifecycle, EPC deduplication and FakeRfidPort
- License
- MIT
- Size
- 2.8 KB
- SHA-256
- 2d3d63b7e871ae50dd43bf4f4fed8aacdccffa4b377d1a1bfcc328f4012c2bf2
Original RuggedLayer source; reviewed 2026-08-03
Download from GitHub
UROVO / upstream / sample repository
Latest UROVO Android sample source
Download the current public repository archive directly from GitHub when you need to compare the packaged v4.1.0326 materials with the latest upstream branch.
- Version
- master / upstream repository
- Platform
- Android / Java
- Scope
- ScanManager, DeviceManager and terminal sample families in the public repository
- License
- No SPDX license detected; UROVO public sample source
Public UROVO repository; upstream branch may change
Download from GitHub
UROVO / community / community example
Flutter scanner bridge
A cross-platform bridge pattern. Its README states that proprietary UROVO drivers are not included, so connect the matching native SDK separately.
- Version
- main / community repository
- Platform
- Flutter / Android
- Scope
- EventChannel bridge around UROVO barcode scanning
- License
- MIT
Community code; no RuggedLayer hardware validation
Download from GitHub
SEUIC (Dongji) / community / community example
Dongji UHF inventory workflow
A warehouse workflow example for understanding how an application can own inventory rules around a native RFID boundary. Validate the device and plugin separately.
- Version
- master / community repository
- Platform
- uni-app / Android
- Scope
- Inbound, outbound, stocktaking and traceability around a seuic-uhf plugin
- License
- Apache-2.0
Community code; not tested by RuggedLayer
Download from GitHub
SEUIC (Dongji) / multi-vendor / community example
Multi-vendor RFID middleware
A multi-vendor hardware abstraction and mock-reader reference that names Seuic adapters. Inspect its bundled drivers and NOTICE before selecting dependencies.
- Version
- main / community repository
- Platform
- Kotlin / Android
- Scope
- Hardware abstraction, mock reader, inventory and tag operations
- License
- Apache-2.0 with NOTICE
Community code; exact device and driver scope require validation
Downloads make the code available; they do not make every API compatible with every model. Confirm the device, region, Android, firmware and SDK baseline before deployment. GitHub downloads remain governed by the license and dependency terms in the source repository.
Local SDK review / public guide map
Choose a capability before choosing an API.
The local UROVO package was reviewed by capability. The public guides keep device-specific bindings behind an adapter and show which areas need a model-specific SDK, device, permission or security review.
Guide available
Barcode / scanner
Lifecycle, output transport, result normalization, parameters and failure recovery.
Scanner sample reviewedOpen guideGuide available
Compatibility baseline
Exact model, software stack, operating conditions and evidence status for a reproducible test.
Device and key-control samples reviewedOpen guideGuide available
Printer
Bounded page models, status mapping, queueing, paper and thermal recovery.
Printer sample reviewedOpen guideControlled guide
Cards and secure operations
ICC, PICC, magnetic stripe, PIN and secure-element work with explicit security ownership.
Card and secure samples reviewedOpen guidePublic pattern
Test adapter
Fake device ports that keep CI fast and business rules independent of hardware.
Original test doubleOpen guideGuide available
Hardware key mapping
Snapshot, apply, restore and validate physical key behavior without stranding system input.
Key-map sample reviewedOpen guideGuide available
Device capability and deployment controls
Read-only capability snapshots, version baselines, permission boundaries and reversible deployment controls.
Device identity and key-control samples reviewedOpen guideGuide 01 / Barcode
Scanner integration in four predictable boundaries.
A scanner should not be a mystery hidden inside every screen. Open it when the workflow starts, register the result path, normalize the payload, and close it when the workflow ends.
- 01Choose the transport
Use wedge for a fast form retrofit, intent for an explicit event, or the device SDK when you need direct control.
- 02Normalize the event
Convert text, raw bytes, symbology and capture time into the object your application owns.
- 03Handle bad input
Reject empty and oversized payloads, surface timeouts, and protect against duplicate broadcasts.
- 04Close the session
Stop decoding and release the manager on every exit path, including background and error states.
InputBarcode, symbology, raw bytes
OutputApplication-owned CaptureEvent
Test firstEmpty, duplicate, timeout, resume
Code pattern / Kotlin
Keep business logic independent from device APIs.
This small interface is deliberately vendor-neutral. A UROVO, SEUIC or other device implementation can sit behind it while inventory, receiving and field-service rules stay easy to test.
- One event shape for the application
- One lifecycle owner for the peripheral
- One fake adapter for CI tests
interface CapturePort {
fun start()
fun stop()
fun setListener(listener: (CaptureEvent) -> Unit)
}
data class CaptureEvent(
val value: String,
val symbology: String?,
val capturedAt: Instant,
)
class CaptureAdapter(
private val device: CapturePort,
) {
fun begin(onCapture: (CaptureEvent) -> Unit) {
device.setListener(onCapture)
device.start()
}
fun end() = device.stop()
} Original starter pattern. No vendor binary is required.
Engineering diagrams / How the pieces fit
Four diagrams for the first integration conversation.
Use these diagrams when a team is deciding how to connect a rugged Android device. They show ownership, event flow, integration choices and the evidence required before deployment.
01System architectureOwnership before API calls
Application UIScreen state, operator feedback and retry
WorkflowBusiness rules and normalized events
Port / adapterLifecycle, mapping and version boundary
Approved SDKPrivate binding for the target configuration
DeviceModel, firmware, peripherals and policy
02Lifecycle sequenceOne capture from start to release
- 01Screen
Starts the workflow and gives the user a clear active state.
- 02Workflow
Requests capture and owns the normalized result.
- 03Adapter
Opens, registers, starts and translates the device event.
- 04Device
Returns data, then stops and closes on success or failure.
03Integration decision flowChoose transport by workflow
- Question 01Is this a focused legacy form?YESKeyboard wedge for the smallest retrofitNOContinue to an explicit application event
- Question 02Does the application own the event?YESIntent or broadcast behind a receiver adapterNOConfirm who owns focus and delivery
- Question 03Do you need direct lifecycle or configuration control?YESApproved SDK adapter with model evidenceNOKeep the simpler transport and test the boundary
04Validation data flowFrom configuration to decision
ConfigurationModel, region, OS, firmware, SDK and app build
MethodWorkflow, inputs, environment, repetitions and expected result
ObservationNormal result, empty data, timeout, duplicate, busy and recovery
DecisionSupported, tested, partially supported, not-tested or not-supported
External examples / GitHub
Study proven patterns without copying the device layer.
These repositories are useful for architecture, testing, parsing, lifecycle and concurrency ideas. They are external learning references, not RuggedLayer compatibility evidence or replacements for an approved device SDK.
urovosamples/SDK_ReleaseforAndroid
UROVO / upstream
Start with UROVO sample families
ScanManager, DeviceManager and terminal samples
Use the repository to locate the API family that matches the target workflow. No SPDX license is detected, so do not copy or mirror files without permission.
No SPDX license detectedOpen repositorysnave00/flutter_urovo_scan
UROVO / community
Compare a Flutter bridge
EventChannel and native scanner boundary
Study how a cross-platform app can keep device calls behind a native bridge. The proprietary driver remains a separate dependency and model validation is still required.
MIT reported by GitHubOpen repositoryrafaax/react-native-urovo-rfid
UROVO / community
Study an RFID bridge boundary
React Native events, RFID and trigger controls
Review the JavaScript-to-native boundary only. The README says proprietary UROVO drivers are supplied separately, and GitHub does not report a license for the repository.
No license detectedOpen repositoryaaron-wu007/astoaarUFH
SEUIC (Dongji) / community
Trace a Dongji UHF workflow
uni-app inventory, inbound, outbound and stocktaking
Use the workflow structure to discuss RFID application ownership. The repository is a community example and does not prove support for every SEUIC model or native plugin version.
Apache-2.0 reported by GitHubOpen repositoryrfidsoftwares/OpenRFID-Handheld-Android-Middleware
SEUIC (Dongji) / multi-vendor
Study a multi-vendor HAL
Hardware abstraction, mock reader and tag inventory
Compare the HAL and mock-reader ideas with your own adapter boundary. Its named Seuic adapters still need exact device, driver and release review before use.
Apache-2.0 reported by GitHubOpen repositoryandroid/architecture-samples
Android / platform
Study the architecture
UI, domain and data boundaries
Use repository contracts and state ownership as a reference for keeping device adapters out of business screens.
See repository licenseOpen repositoryandroid/testing-samples
Android / platform
Use the testing pattern
Local, instrumentation and fake dependencies
Compare what belongs in a fast unit test with the small hardware smoke test that needs an actual handheld.
See repository licenseOpen repositoryzxing/zxing
Community / barcode
Read the parsing boundary
Barcode parsing and format validation
Study input validation and format handling; this repository is not a device scan engine or a UROVO SDK replacement.
See repository licenseOpen repositoryandroid/camera-samples
Android / platform
Study lifecycle handling
Permissions, resources and foreground/background state
Apply the lifecycle discipline to scanner, printer and other peripherals that must be stopped and released.
See repository licenseOpen repositoryKotlin/kotlinx.coroutines
Kotlin / platform
Study structured concurrency
Cancellation, dispatchers and async work
Use cancellation and ownership patterns when a device operation can outlive a screen or be interrupted by a retry.
See repository licenseOpen repositoryRead each repository license before copying code. Rewrite examples around your own domain objects and keep model-specific bindings private until their release and test scope are approved.
Guides 04–07 / Device surfaces
Peripherals and deployment controls need the same discipline.
Start with a bounded operation, preserve the previous state, and make recovery visible to the operator.
Print a page, not a pile of calls
Open the printer, check status, render text or barcode into one page, print, feed, and close it in a `finally` path.
Verify: paper width, busy state, out-of-paper, heat, voltage and cancellation.
Map keys with a restore button
Read the original mapping before changing a physical key. Keep system navigation and emergency behavior out of the demo.
Verify: reboot persistence, reset behavior, focus handling and physical recovery.
Separate sensitive modules
ICC, PICC, magnetic-stripe, PIN and secure-element integrations require their own security and compliance boundary.
Verify: data minimization, approved test fixtures, ownership and redacted logging.
Inspect before you deploy
Read the device baseline first, keep administrator operations explicit, and make key changes reversible with a physical recovery path.
Verify: model, OS, firmware, SDK, permissions, reboot behavior and restore.
Before you ship
Compatibility is a record before it becomes a deployment handoff.
Use the same checklist for a lab run, a customer pilot and a volume deployment. One model or one firmware build does not prove every configuration.
| Device | Exact model, scanner or peripheral option, accessories and region variant |
|---|---|
| Software | Android version, firmware build, SDK version and application build |
| Method | Trigger mode, output mode, symbologies, label set, repetitions and environment |
| Result | Expected output, timeout, empty data, duplicate data, busy and recovery behavior |
| Decision | Supported, tested, partially supported, not tested or not supported |
Advanced modules
More depth when the workflow needs it.
The local UROVO SDK package includes device, scanner, printer, key-map, card and secure-element examples. The public Wiki turns those materials into original, versioned guides only after the exact API, code and redistribution permissions are recorded.
Request a device-specific guide