Executive summary
RealWear Navigator 520 development doesn't require a separate speech SDK for basic voice interaction. WearHF is part of the device software. It can inspect an Android screen, identify supported interactive views and expose voice commands for them. That means a standard Android button labeled CONTINUE can be activated by saying “CONTINUE” without importing a RealWear library.
Start with a standard Android app and test it on the target Navigator firmware. WearHF can recognize supported screen controls without any app-side speech code. Add a view directive in android:contentDescription when a control needs alternate phrases or special behavior. Use OVERRIDE_COMMANDS only when the app must take control of the recognizer and handle commands itself. Each of these paths has a different effect, as described below.
Important: “No SDK” doesn't mean “no code.” You still build the Android interface and business logic. The app doesn't need a separate RealWear speech SDK for basic voice control because WearHF provides that capability at the device level.
Core concept: You don't open WearHF, install WearHF or import a WearHF SDK for basic voice control. WearHF runs in the background as part of the RealWear operating system.
What is the RealWear Navigator 520?
The RealWear Navigator 520 is a rugged monocular assisted-reality computer designed for frontline work such as maintenance, inspection and field service. RealWear’s Navigator 500/520 firmware 2.x is based on Android 13, and the Ari OS 2.0 maintenance release of September 17, 2026 (firmware 3.0, build 3.0.3-15, offered to devices on build 2.2.3-33) moves the device to Android 16. Firmware roadmaps can change, so treat the device OS as a deployment constraint: record the tested firmware build, Android API level, app minSdk/targetSdk and device model in your release matrix. Don't infer minSdk or targetSdk solely from the headset’s Android version.
For developers, this means you build and package a normal Android app. WearHF runs on the device and can expose supported controls to voice. It doesn't implement your workflow, authorize a business action or replace app-side validation.
What is WearHF?
WearHF is RealWear’s built-in speech and hands-free interaction service. It interprets supported Android views and screen directives, then activates a view or sends a speech event according to the selected integration. Basic view interaction doesn't need a separate RealWear speech library. Embedded directives are parsed from android:contentDescription, and programmatic commands use documented Android broadcast intents. Don't confuse a view click with a recognizer override: an override takes control of the recognizer and can suppress embedded/scripted commands until it's restored.
What you need before building your first app
· A Navigator 520 running the firmware build you intend to support. Record its exact build and Android version.
· A Windows, macOS or Linux computer.
· Android Studio with the Android SDK and Platform Tools (ADB). Use the Android API level your app requires and validate it against RealWear’s supported firmware.
· A USB-C data cable.
· No RealWear SDK for the first app.
· A business workflow to test, such as advancing an inspection step or reporting an equipment issue.
How to build a voice-controlled Android app without a RealWear SDK
Step 1: Create a normal Android project
For this walkthrough, start with an Android Views project. In Android Studio, choose a Views-based Empty Activity (not a Compose-only template), then select Java or Kotlin. The examples below use Java. Compose can also work with WearHF on supported software, but you should test its semantics and accessibility tree on the target build.
1. Open Android Studio and select New Project.
2. Choose a Views-based Empty Activity. If the wizard offers language and minimum SDK fields, select Java and set minSdk to the lowest Android API your app actually supports. Don't copy a value from this example without checking your dependencies and device fleet.
3. Enter the app details. Set the app name, package name and save location, then create the project.
4. Wait for the project to open. Android Studio completes the Gradle sync and opens the project.
Don't add anything yet: You aren't looking for a RealWear project template. The point of the first build is to prove that a standard Android app can run on the Navigator 520.
Step 2: Add one Android button and connect it to Java
Start by creating one button. You'll add its Android layout, connect its click action in Java and then test it on the device.
1. In Android Studio’s Project panel, open app > res > layout > activity_main.xml. The full file path is app/src/main/res/layout/activity_main.xml.
2. Select Code in the layout editor. Replace the file contents with the complete XML shown below.
XML: One button with a WearHF command
Paste the complete layout into activity_main.xml, then save the file:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical" android:padding="24dp">
<Button android:id="@+id/continueButton" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="CONTINUE" android:contentDescription="hf_commands:CONTINUE" />
</LinearLayout>
Quick explanation: `LinearLayout` stacks its contents vertically. `android:text` is the visible button label. `android:contentDescription` contains the WearHF directive. Android accessibility services also read this field, so test that the control remains understandable to your users.
Next, open app > java > your package > MainActivity.java in the Project panel. The full path is app/src/main/java/<your.package.name>/MainActivity.java. Keep the generated Activity class and `onCreate()` method.
If it's missing, add `import android.widget.Button;` to the imports at the top of MainActivity.java. Inside the existing `onCreate()` method, paste these lines immediately after `setContentView(R.layout.activity_main);`:
Button continueButton = findViewById(R.id.continueButton); continueButton.setOnClickListener(v -> openNextStep());
Add this method below `onCreate()` but before the final closing brace of the MainActivity class:
private void openNextStep() { // Navigate to the next inspection or work-order step. }
How to adjust it: Change `android:text` to the label that fits your workflow. Change `hf_commands:CONTINUE` to the phrase workers should say, for example `hf_commands:Continue Work, Next Step`. The XML ID `continueButton` must match `R.id.continueButton` in Java, so if you rename it, update both. Replace the comment in `openNextStep()` with the navigation or business action your app needs. Basic voice control doesn't require a separate WearHF SDK or the `RECORD_AUDIO` permission.
Step 3: Prepare the Navigator 520 for Android development
The development computer needs ADB authorization to install and debug the app. Use a USB-C cable that supports data. Charge-only cables won't enumerate as an ADB device.
1. Open Advanced Settings. From the Navigator Home screen, say MY SETTINGS to reach the Android settings list.
2. Open About Device. Say ABOUT DEVICE, then PAGE DOWN until Build Number is visible.
3. Enable Developer Options. Say BUILD NUMBER repeatedly, about seven times, until the device confirms that developer mode is enabled.
4. Open Developer Options. Say NAVIGATE BACK, then SYSTEM, then DEVELOPER OPTIONS.
5. Enable USB debugging. In Developer Options, turn on USB debugging.
6. Connect the USB-C cable and approve the RSA debugging prompt on the device. Confirm the connection with `adb devices`. The device should appear as `device`, not `unauthorized`.
If Android Studio doesn't list the headset, run `adb devices`. If it shows `unauthorized`, unlock the headset and approve the RSA prompt. To reinstall from the project root, use `adb install -r app/build/outputs/apk/debug/app-debug.apk`, replacing the path if your build variant or APK name is different. Use Android Studio Logcat or `adb logcat` to inspect crashes and application logs.
USB debugging is a development setting. Disable it after lab testing or manage it under your organization’s device security policy. Don't leave development access enabled on production fleet devices.
Step 4: Run the app on the Navigator 520
1. Select the Navigator in Android Studio. Use the device selector in the top toolbar and choose the connected RealWear device.
2. Click Run. Select the green Run triangle or use Run > Run 'app'.
3. Wait for installation. Android Studio builds the APK and installs it on the Navigator through ADB.
4. Launch the installed app from the device’s application launcher, or run `adb shell monkey -p your.application.id 1` from a development terminal. Replace `your.application.id` with the applicationId in the app module’s Gradle build file.
5. Confirm that the CONTINUE button is visible and enabled.
Step 5: Test WearHF without adding any SDK
WearHF is already running on the Navigator 520. With only the CONTINUE button on screen, test this control first:
1. Say CONTINUE and verify that the app’s normal click listener runs exactly once.
2. Say SHOW HELP to inspect the command WearHF exposes for this screen. Confirm that it shows CONTINUE.
3. Check the WearHF indicators and test numeric selection if it's offered. Don't rely on an indicator as the only way to identify a safety-critical action.
Optional: Add a second action after the CONTINUE test
Once the first button works, you can add REPORT ISSUE. In activity_main.xml, place this Button inside the LinearLayout, below CONTINUE and before </LinearLayout>:
<Button android:id="@+id/reportIssueButton" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="REPORT ISSUE" />
In MainActivity.java, add this listener inside onCreate(), after the CONTINUE listener:
Button reportIssueButton = findViewById(R.id.reportIssueButton); reportIssueButton.setOnClickListener(v -> openIssueReport());
Add openIssueReport() below onCreate(), inside MainActivity. Replace the comment with your app's issue-report workflow:
private void openIssueReport() { // Open the equipment issue form. }
Rebuild and reinstall the app, then say REPORT ISSUE. Confirm that the issue-report workflow opens.
Conclusion
Developing for the RealWear Navigator 520 without a dedicated SDK shows that clean, standard Android code is already voice-capable, relying on the built-in WearHF service to turn visible views and contentDescription directives into intuitive hands-free controls. For technical teams, this avoids third-party library bloat and complex speech engines while keeping core business logic within standard Android architecture. From a business perspective, this approach accelerates time to market and minimizes deployment costs: enterprises can directly leverage existing Android apps and in-house developer skill sets, sidestep proprietary SDK lock-in and smoothly modernize frontline workflows without disrupting their software stack.
For a first enterprise prototype, build one inspection or maintenance screen, verify view labels and accessible descriptions, then test voice activation on the exact Navigator 520 firmware used by the pilot fleet. Add embedded directives for specific UI needs, and add recognizer overrides only when the workflow requires full command ownership.
