mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 04:46:08 +00:00
Add app-wide 3DoF for VITURE, RayNeo and XREAL glasses and 6DoF for Luma Ultra (#1035)
* Add VITURE glasses support: hardware control, 3D, head tracking Glasses get their own controller over the MCU (permission, 120 Hz default, brightness, volume, sunblock, 2D/3D) and the game moves onto them when plugged in. The IMU drives Cardboard head tracking and the SteamVR driver. 3D falls back to one eye's view on phones that can't send the 3840x1080 signal. Options open from a glasses button in game and on the Steam page. * Drop the glasses settings like Steam's: Play-style button, Settings lip, tabs * Hang the glasses Settings lip over the top of the button * Space glasses MCU commands so the IMU rate sticks, fit fixed resolutions to the glasses * Keep Steam alive with SteamVR registered, run SteamVR at the glasses' rate, keep the glasses lip on top * Fit VR games on the glasses: full view, seated origin at the head, pad hands reach with the d-pad * Let the pad hands reach a metre out so buttons with deep colliders press * Show every VR frame in order at 120 fps: wait for SteamVR's GPU work, present only finished copies, skip the grace on idle shared counters * Glasses: SteamVR starts and stops with them, closer view with a field of view setting, Recenter on the pad * Glasses: SteamVR field of view defaults to 90° * VR pad hands: sticks move and aim the hands, left stick click switches the sticks to the game, d-pad pulls a held hand * Glasses: Play SteamVR beside the glasses button instead of starting SteamVR with them, pad hands drawn as Index controllers and off while other VR controllers are connected, glasses sheet tabs sized like Steam's * Track glasses mode, refresh-aware glasses window, align Play SteamVR with Play Steam * Fix 3D on the glasses: full-res SteamVR presenter, revert VR 3D at session end, coalesce vsync ticks, no session restart after end * Address review: glasses output after installs and session end, VR revert retry, display fallback, presenter swapchain retry, agent hex checks, drawer bumpers, glasses translations, docs * Harden VITURE stereo negotiation and output refresh tracking * Localize stereo recovery feedback and record Astra reconnect tests * Improve test failure diagnostics and refresh Astra firmware findings * Handle VITURE docks separately and reject truncated USB frames * Glasses: remember a 3D fallback per model, docks as display only, VR timing fixes - A 3D attempt that ends at the 640x480 fallback is remembered for that glasses model, so Play SteamVR no longer blacks out the glasses after every restart; Retry clears it and "3D for VR games" stays reachable - A VITURE Mobile Dock on its own no longer counts as glasses; through a dock Play SteamVR is hidden and the sheet shows the output and why there is no control - HDR is probed on the glasses when the session starts there - Glasses frames with a mismatched checksum are marked in the status frame log - SteamVR layer and driver vblank counters stay monotonic across refresh changes; one-eye render scale applies from activation and on mono/3D switches - Compositor binds announce the refresh clients were last told; the presenter retries a failed first swapchain - Dead strings and helpers removed; docs updated * Glasses: drop USB frames with a bad checksum * Glasses: count frames dropped for a bad checksum * Feat/viture xr (#907) * Add RayNeo Air and GT support to the XR glasses pipeline * Add RayNeo Air and GT support to the XR glasses pipeline * Checkpoint glasses tracking, calibration, and SteamVR launch integration * Checkpoint glasses tracking, calibration, and SteamVR launch integration * Add XREAL 1S support and correct GT and Pro 2 tracking * Add XREAL 1S support and correct GT and Pro 2 tracking * Fix mirrored glasses tracking and recover SteamVR after device loss * Fix mirrored glasses tracking and recover SteamVR after device loss * Document confirmed XREAL 1S brightness control * Document confirmed XREAL 1S brightness control * Fix SteamVR glasses defaults and rendering controls * Fix SteamVR glasses defaults and rendering controls * chore: keep only the 3 newest session log folders (#852) * chore: add agent comment rules (#748) Co-authored-by: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> * Fix SteamVR polling, VITURE checksums, and fence tracking Keep manual SteamVR launches polled, discard corrupt VITURE packets, and retire Vulkan fences out of order without blocking submissions at a fixed capacity. Preserve the contiguous completion watermark used by the presenter. Fix optional Windows launcher configuration and audited helper staging. Add Android, Windows, and native tracker regression coverage. * Fix SteamVR polling, VITURE checksums, and fence tracking Keep manual SteamVR launches polled, discard corrupt VITURE packets, and retire Vulkan fences out of order without blocking submissions at a fixed capacity. Preserve the contiguous completion watermark used by the presenter. Fix optional Windows launcher configuration and audited helper staging. Add Android, Windows, and native tracker regression coverage. * fix: wireless ADB page names the child-process switch the way Android shows it (#848) * l10n: refresh stale and untranslated strings in es, fr, ko, ru (#850) * l10n: refresh stale and untranslated strings in es, fr, ko, ru - mode_added_art_hint: now mentions Steam then SteamGridDB (all four locales). - wincomp_needs_installer / wincomp_installers_note: es and ko still described the old "coming soon" behaviour; align with the current English text. - summary_remove_game: was still English in all four locales. Machine-assisted translation; native-speaker review is welcome. * l10n(es): say registro, not grabación, for the missing installer record --------- Co-authored-by: ovurrsl <ovurrsl@users.noreply.github.com> * fix: a failed cloud save recovery no longer ends the app (#846) The cloud-recovery thread started at every app start had nothing to catch an error, so one went to CrashHandler, which halts the process with status 2. In unit tests the thread can outlive the test that started it, fail on the torn-down preferences, and take the whole test run down. The error is now logged and the thread ends. Co-authored-by: Kirk <12691869+KirkPatrickJunsay@users.noreply.github.com> * fix: an interrupted Linux runtime download resumes instead of starting again (#847) * fix: an interrupted Linux runtime download resumes instead of starting again installOnce() asked the downloader to resume but always deleted the archive in its finally block, so the next attempt began at zero. The archive is now named after the release version and checksum, a failed download keeps what it fetched, and archives of other releases (and the old fixed name) are removed. A checksum or extraction failure still deletes the file. * test: Downloader resumes a cut-off download from the bytes it kept Starts a socket server that promises the whole file, hangs up part way and then answers a Range request, and checks that the second downloadFile call resumes with the right offset and ends with identical bytes. * fix: a resumed download discards a 206 that does not start where the kept bytes end Downloader appended every 206 response to the partial file without looking at Content-Range. A server or proxy that answers a Range request with a different offset would leave a corrupt file. Check that the range starts at the kept length; otherwise delete the partial file and start again without a Range header. Adds a test with a server that answers the Range request from offset 0. --------- Co-authored-by: ovurrsl <ovurrsl@users.noreply.github.com> * l10n: German, French, Spanish, Italian, Portuguese and Russian for the zRAM, reset-settings and store free-space strings (#849) * l10n: German, French, Spanish, Italian, Portuguese and Russian for the zRAM, reset-settings and store free-space strings Adds the strings values-de, values-it and values-pt were missing (14 each) and the six that values-fr, values-es and values-ru were missing. Machine-assisted drafts that follow each file's existing register and terms; native review is welcome. * l10n: correct missing active swap translations --------- Co-authored-by: ovurrsl <ovurrsl@users.noreply.github.com> Co-authored-by: xXJsonDeruloXx <danielhimebauch@gmail.com> * fix: droiddeckctl reaches variant-package builds (recover #842) (#854) fix: droiddeckctl reaches builds shipped under a variant package The provider authority and the start Activity's component were fixed to com.droiddeck.launcher, so droiddeckctl could not talk to the antutu, ludashi or pubg builds from tools/release/variants.txt. DROIDDECK_PACKAGE now picks the package; the Activity's class name stays the same in every variant. Co-authored-by: angelrenefm <17342133+angelrenefm@users.noreply.github.com> * feat: droiddeckctl reports on-screen pacing (recover #843) (#855) feat: droiddeckctl pacing reports the frames that reached the screen Reads SurfaceFlinger's timestats for the game's layer (or the session's SurfaceView) over a capture: frames on screen, fps on screen, the present-to-present histogram and how many intervals were off the usual cadence. Records split by a refresh-rate change are summed. A game's own fps counter counts frames handed over, so it can't show dropped or doubled frames. Co-authored-by: angelrenefm <17342133+angelrenefm@users.noreply.github.com> * fix: Steam can restart more than twice in a session (#754) * fix: Steam can restart more than twice in a session Every exit 42 counted toward the cap that stops an update which will not install, and the count was never cleared, so the third restart of a session ended it however far apart they were. A client that ran for a minute before asking is not that loop: the count starts again. * fix: measure the client's run time as it exits The time spent collecting logs and checking FEX after the client exits counted toward its run, so a slow cleanup could make a quick exit 42 look like a long one and clear the count. --------- Co-authored-by: Kirk <12691869+KirkPatrickJunsay@users.noreply.github.com> Co-authored-by: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> * fix: the front end keeps its page when the Fold is folded or unfolded (#832) * fix: the front end keeps its page when the Fold is folded or unfolded MainActivity, FileManagerActivity, FilePickerActivity and StoreLoginActivity did not declare the screen-size configuration changes, so folding or unfolding a foldable recreated them and dropped their in-memory state. They now handle orientation, screenSize, screenLayout, smallestScreenSize and density themselves, like SessionActivity already does. uiMode is left out on purpose. * fix: store login keeps rebuilding its toolbar when the display density changes StoreLoginActivity builds its toolbar in code with dp-to-pixel values taken at creation time and has no onConfigurationChanged. It no longer declares density in configChanges, so a density change recreates it as before this PR. Size and layout changes are still handled in place. --------- Co-authored-by: ovurrsl <ovurrsl@users.noreply.github.com> * Release pointer buttons without replaying stale motion (#803) * Fix cursor warping on native touch down * Preserve input cleanup without replaying stale pointer motion --------- Co-authored-by: siyuan.qsy <siyuan.qsy@alibaba-inc.com> * l10n: translate the strings added since #284 into zh-CN, zh-HK, zh-TW and ja (#539) * l10n: translate the 184 strings added since #284 (zh-CN/HK/TW, ja) The stores, cloud saves, Windows components, Steam touch, desktop removal and background-downloads strings landed after #284's translation snapshot, so every one of them fell back to English. Translate all 184 into Simplified Chinese, Traditional Chinese (Taiwan and Hong Kong) and Japanese, keeping each locale file's own vocabulary (工作階段/會話, 解除安裝/卸載, 元件/組件, 設定). Also fix four Hong Kong strings that kept the simplified 着色器. * l10n(zh): fix stale and ambiguous strings found in review Severe: summary_remove_game was untranslated English in all three files; mode_added_art_hint, wincomp_installers_note and wincomp_needs_installer still described the pre-#480/#492 English. Also: distinguish the Setup wizard from Android system settings in zh-HK/zh-TW (初始設定 / 系統設定 / Android 設定), unify library as 收藏庫, component as 組件 in zh-HK, session as 會話 in zh-HK, account as 帳戶 in zh-HK, Trending as 趋势/趨勢, Forget as 清除, reword the re-applied-at-launch, action-failed and already-in-Games strings, and play as 執行/開啟遊戲 in zh-TW/zh-HK. * l10n(ja): fix stale and ambiguous strings found in review --------- Co-authored-by: Dantalian <Dantalian-dev@users.noreply.github.com> Co-authored-by: xXJsonDeruloXx <danielhimebauch@gmail.com> * Rebuild and verify Windows VR runtime components * Rebuild and verify Windows VR runtime components * Add top, bottom, and centered picture positions for Steam sessions (#871) * fix: dependency scan ignores folders above the game folder (#859) * DroidDeck-Proton: get releases from the Droid-Deck org repo DroidDeck-Proton is now built and released on Droid-Deck/DroidDeck-Proton (11-9.1 is Latest there), so the Components page, the update check and the guest installer read releases from the org repo instead of The412Banner's. * feat: low-latency controller and touch toggles in the session drawer (#808) * fix: SteamGridDB lookups no longer stick as "no match" after a failure; add a search to the art chooser (#876) * feat: Steam home wall fills from the signed-in library instead of store picks (#878) * test: cover GPU family and support classification (#880) * Fix local builds on Linux failing after the first Comet build (#866) * feat: sort the store library and installed tabs, and switch between card and list views (#798) * feat: three-finger tap toggles Steam's on-screen keyboard in game mode (#782) * fix: keep Quest-patched Turnip as the auto default (#853) * Fix deploy_local.sh and droiddeckctl not finding a phone connected over wireless debugging (#864) * fix: keep proot sessions alive when the kernel loses fork events (#457) * fix(quest): correct desktop and Steam display corruption across sessions (#733) fix(quest): stabilize desktop and Steam layer presentation Keep Quest SDR scenes and the black backdrop off the Android Vulkan swapchain regardless of session order or HDR preferences. Only report the first frame after client content is submitted. Add backdrop lifecycle and first-frame regression coverage. Record the user's successful Quest 3 Test 2 result. Co-authored-by: xXJsonDeruloXx <danielhimebauch@gmail.com> * fix: keep SteamVR syscall hooks and report Steam crashes (#905) * fix: preserve SteamVR syscall hooks * fix: report Steam crashes through gamescope * fix: honor glasses pacing and resolution in SteamVR launches --------- Co-authored-by: connor g <connorsspam1992@gmail.com> Co-authored-by: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Co-authored-by: Yassine Gherbi <y.gherbi.dev@gmail.com> Co-authored-by: Resul Övür <92828257+ovurrsl@users.noreply.github.com> Co-authored-by: ovurrsl <ovurrsl@users.noreply.github.com> Co-authored-by: Kirk <kirtoy.junsay@gmail.com> Co-authored-by: Kirk <12691869+KirkPatrickJunsay@users.noreply.github.com> Co-authored-by: xXJsonDeruloXx <danielhimebauch@gmail.com> Co-authored-by: angelrenefm <17342133+angelrenefm@users.noreply.github.com> Co-authored-by: asdf17128 <asdf17128@gmail.com> Co-authored-by: siyuan.qsy <siyuan.qsy@alibaba-inc.com> Co-authored-by: Dantalian <wsu091227@qq.com> Co-authored-by: Dantalian <Dantalian-dev@users.noreply.github.com> Co-authored-by: The412Banner <the412banner@users.noreply.github.com> Co-authored-by: The412Banner <205237651+The412Banner@users.noreply.github.com> Co-authored-by: FX1922 <120828496+FX192@users.noreply.github.com> Co-authored-by: Muaz Kadan <32595066+muazkadan@users.noreply.github.com> Co-authored-by: kingokksa <47888451+kingokksa@users.noreply.github.com> Co-authored-by: Jamie Schenker <jam1esch3nk3r@gmail.com> Co-authored-by: Jagger15 <jagger2333@live.com> * Glasses: keep a pending 2D restore and the SteamVR recovery offer, show Play SteamVR only with a picture * Translate the glasses calibration, XREAL and SteamVR recovery strings * SteamVR recovery: give a finished teardown time to collect logs before restarting * Credit the projects the XR glasses support builds on * Joy-Cons: SteamVR hands from their gyro while SteamVR runs, one combined pad otherwise * Add experimental Luma tracking and stabilize SteamVR launches Add native Luma Ultra spatial tracking, optical controllers, and stereo calibration with DroidDeck styling, imperial/metric measurements, and pending recenter recovery. Include the pinned hand model and calibration board. Keep live guest and SDK files outside Android's evictable cache. Filter the Adreno 840 sysmem override in the shared SteamVR helper, serialize timeline mirroring, retain invalid optical controllers without event floods, and prevent an unprivileged scheduling fallback from lowering compositor RTTIME. Validation: latest APK build and runtime freshness checks pass; 247 affected glasses/calibration tests pass. Native VR, helper, and packaging regressions pass. Two earlier phone library launches sustained 60 fps for 308 and 188 seconds without recovery or restart. The newer calibration APK is installed and checksum-verified; calibrated-hand and sustained gameplay acceptance remain pending. One existing Android test requires Windows symlink privileges. * Headsets: settings badge on Play SteamVR instead of a top-right button, both shown only once connected * Hand tracking: camera-tracked Joy-Cons and bare hands in SteamVR, drawn as white gloves - Joy-Con movement from the accelerometer (report reordering, per-Joy-Con calibration, zero-velocity updates) - MediaPipe pose and hand landmarks from the device camera, placement check, per-hand Kalman filter with the Joy-Con - No controller connected: bare camera hands with Quest-style gestures, 1€ filtered, rendered as a white glove model built from a distance field - SteamVR safe mode cleared before each start so one crash no longer blocks the driver * Improve Luma Ultra tracking and isolate device-specific controls Refine stereo hand and Joy-Con tracking, gesture release, calibration, recovery UI, diagnostics, display modes, and compositor handling. Keep Ultra controls and input routing behind a live SDK-confirmed Carina connection; clear retained spatial mode when other glasses connect. Add optional UVC transport with pinned dependencies and packaged notices. Validation: 456 Android tests, ARM64 VR build and native regressions, 47 tooling tests, SDK/UVC-enabled and disabled builds, and 150 packaged runtime checksums. Two shader compilation tests skipped because the compiler is unavailable. Hardware interaction gates remain experimental. * Delay Luma Ultra 6DoF until SteamVR settles Suspend spatial SDK startup while SteamVR launches, then restore it two seconds after RUNNING is confirmed. Preserve saved tracking preferences and automatically recenter same-device restoration, including cancellation and early stop. Discard superseded launch requests and status replies after session teardown. Validation: 128 focused JVM tests passed on the isolated commit snapshot; 129 passed with the current local hand-tracking work. Debug build and runtime checks passed, and the reviewed APK was installed and hash-verified on the phone. * Clarify glasses and phone camera tracking options Separate Luma Ultra camera controls from phone-camera tracking so the two hand-tracking switches have clear sources. Label bare-hand controllers and Joy-Con position tracking explicitly, explain physical Joy-Con inputs and camera priority, and update the camera prompt and calibration guidance. Use fresh phone section and toggle labels so existing translations do not hide the distinction. Preserve tracking behavior and saved preferences. Validation: 39 existing UI tests, debug build, and packaged runtime verification passed. Reviewed changes and installed the APK on the connected phone. * Fix tracking handoff and shared runtime regressions Release spatial ownership and controller overrides when output returns to the phone. Preserve USB-loss recovery, keep Vulkan submissions asynchronous, clean persistent guest scratch on runtime removal, and clarify the 6DoF head-tracking control. * Apply smart-glasses virtual screens across DroidDeck menus * Finalize Luma hand baseline and document smart-glasses support Keep raw grayscale-to-RGB Full hand inference, wrist-only Joy-Con reconstruction, bounded visual holds, and the dead-zone rollback. Retain opt-in steady aim, recenter controls, reproducible Lite models, and the JPEG-padding fix. Remove unsuccessful benchmark-only and USB transport experiments. Document the cross-brand 3DoF matrix, Luma Ultra 6DoF, SDK requirements, and app-wide screen behavior. * Fix executable permission for SteamVR launcher * Address hand tracking and VR review findings * Bound stereo recovery test image comparison memory * Localize smart-glasses setup and tracking diagnostics Move calibration controls, status messages, validation errors, distance labels, and printed-board instructions into Android string resources. Add and update machine-assisted translations in all 32 supported non-English locale catalogs, with corrections for recentering, hand tracking, product names, and measurements. Keep print instructions within the page using text layout that supports wrapping and right-to-left text. Correct the Lite model toggle description to reflect its Lite palm detector and Lite landmark model. Add locale coverage, format-argument, line-break, and measurement checks, plus French and Arabic calibration UI tests. Preserve tracking calculations and the shared runtime storage behavior. Validation: Android resource and Kotlin compilation; 3 localization checks; 68 focused tests; 1,597 JVM tests at a 512 MB heap; French and Arabic UI renders. * Correct smart-glasses translations from PR review Fix the 42 localization findings covering hand and head terminology, disabled states, calibration dimensions, camera visibility, capture rejection, and menu references. Correct the repeated capture-error ambiguity in related locales and clarify its English source. Keep Romanian setup instructions consistent with the existing informal voice. Extend localization measurement validation to distance hints and retry guidance. Verify the recovery screen's palette-dependent text color with one row-sized pixel buffer and guaranteed bitmap cleanup. Validation: Android resource and Kotlin compilation; 3 localization checks across all supported locales; 68 focused JVM tests at a 512 MB heap. * Work around SteamVR device loss with Adreno 840 Turnip v0.2.0 * Withdraw ineffective SteamVR flushall workaround --------- Co-authored-by: maxjivi05 <maxjividen@gmail.com> Co-authored-by: MaxsTechReview <6025299+maxjivi05@users.noreply.github.com> Co-authored-by: connor g <connorsspam1992@gmail.com> Co-authored-by: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Co-authored-by: Yassine Gherbi <y.gherbi.dev@gmail.com> Co-authored-by: Resul Övür <92828257+ovurrsl@users.noreply.github.com> Co-authored-by: ovurrsl <ovurrsl@users.noreply.github.com> Co-authored-by: Kirk <kirtoy.junsay@gmail.com> Co-authored-by: Kirk <12691869+KirkPatrickJunsay@users.noreply.github.com> Co-authored-by: xXJsonDeruloXx <danielhimebauch@gmail.com> Co-authored-by: angelrenefm <17342133+angelrenefm@users.noreply.github.com> Co-authored-by: asdf17128 <asdf17128@gmail.com> Co-authored-by: siyuan.qsy <siyuan.qsy@alibaba-inc.com> Co-authored-by: Dantalian <wsu091227@qq.com> Co-authored-by: Dantalian <Dantalian-dev@users.noreply.github.com> Co-authored-by: The412Banner <the412banner@users.noreply.github.com> Co-authored-by: The412Banner <205237651+The412Banner@users.noreply.github.com> Co-authored-by: FX1922 <120828496+FX192@users.noreply.github.com> Co-authored-by: Muaz Kadan <32595066+muazkadan@users.noreply.github.com> Co-authored-by: kingokksa <47888451+kingokksa@users.noreply.github.com> Co-authored-by: Jamie Schenker <jam1esch3nk3r@gmail.com> Co-authored-by: Jagger15 <jagger2333@live.com>
This commit is contained in:
+13








authored and
GitHub committed 2026-10-18 08:37:09 -04:00
1 parent
292295ba30
commit
e7bc4b03a5
213 files changed
+22572
-919
No files matched your search
@@ -0,0 +1,66 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
import java.util.Locale
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.RuntimeEnvironment
|
||||
import org.robolectric.annotation.Config
|
||||
import com.droiddeck.launcher.R
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [28])
|
||||
class CalibrationDistanceCheckTest {
|
||||
private val context get() = RuntimeEnvironment.getApplication()
|
||||
private fun board(z: Float)=List(24) { i -> SpatialVector((i%4-1.5f)*.03f,(i/4-2.5f)*.03f,z) }
|
||||
|
||||
@Test
|
||||
@Config(qualifiers = "fr")
|
||||
fun rejectedCaptureExplainsTheProblemInTheSelectedLanguage() {
|
||||
val result = CalibrationDistanceCheck.evaluate(context, .3048f, 3, null)
|
||||
assertFalse(result.accepted)
|
||||
assertEquals(context.getString(R.string.spatial_distance_corners, 3), result.message)
|
||||
assertFalse(result.message.contains("checkerboard corners detected"))
|
||||
assertTrue(result.message.contains("3 / 24"))
|
||||
}
|
||||
|
||||
@Test fun missingAndPartialBoardsExplainVisibilityRatherThanDistance() {
|
||||
for (count in listOf(0,12,23)) {
|
||||
val result=CalibrationDistanceCheck.evaluate(context,.508f,count,null)
|
||||
assertFalse(result.accepted)
|
||||
assertTrue(result.message.contains("$count / 24"))
|
||||
}
|
||||
}
|
||||
@Test fun fullBoardWithRejectedStereoGeometryCannotPass() {
|
||||
assertFalse(CalibrationDistanceCheck.evaluate(context,.508f,24,null).accepted)
|
||||
assertFalse(CalibrationDistanceCheck.evaluate(context,.508f,24,board(.508f).dropLast(1)).accepted)
|
||||
assertFalse(CalibrationDistanceCheck.evaluate(context,.508f,24,board(.508f).toMutableList().also {
|
||||
it[0]=SpatialVector(z=Float.NaN)
|
||||
}).accepted)
|
||||
}
|
||||
@Test fun preservesFiveCentimeterToleranceAndReportsBothUnits() {
|
||||
val locale=Locale.getDefault()
|
||||
try {
|
||||
Locale.setDefault(Locale.US)
|
||||
assertTrue(CalibrationDistanceCheck.evaluate(context,.508f,24,board(.508f)).accepted)
|
||||
assertTrue(CalibrationDistanceCheck.evaluate(context,.3048f,24,board(.3048f)).accepted)
|
||||
assertFalse(CalibrationDistanceCheck.evaluate(context,.508f,24,board(.3048f)).accepted)
|
||||
assertTrue(CalibrationDistanceCheck.evaluate(context,.508f,24,board(.557f)).accepted)
|
||||
val result=CalibrationDistanceCheck.evaluate(context,.508f,24,board(.60f))
|
||||
assertFalse(result.accepted)
|
||||
assertTrue(result.message.contains("60.0 cm (23.62 in)"))
|
||||
assertTrue(result.message.contains("50.8 cm (20.00 in)"))
|
||||
} finally { Locale.setDefault(locale) }
|
||||
}
|
||||
@Test fun checksCameraToCenterDistanceRatherThanOnlyForwardDepth() {
|
||||
val points=board(.4f).map { it+SpatialVector(x=.3f) }
|
||||
assertTrue(CalibrationDistanceCheck.evaluate(context,.5f,24,points).accepted)
|
||||
assertFalse(CalibrationDistanceCheck.evaluate(context,.4f,24,points).accepted)
|
||||
}
|
||||
@Test fun rejectsInvalidRequestedDistances() {
|
||||
for(distance in listOf(0f,Float.NaN,Float.POSITIVE_INFINITY)) {
|
||||
assertThrows(IllegalArgumentException::class.java) { CalibrationDistanceCheck.evaluate(context,distance,24,board(.5f)) }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.annotation.Config
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk=[28],manifest=Config.NONE)
|
||||
class CalibrationObservationDataTest {
|
||||
private fun view(count: Int=24) = JSONObject().put("objects",JSONArray((0 until count).map {
|
||||
JSONArray(listOf((it%4+1)*0.03,(it/4+1)*0.03,0.0))
|
||||
})).put("left",JSONArray((0 until count).map { JSONArray(listOf(100.0+it,200.0)) }))
|
||||
.put("right",JSONArray((0 until count).map { JSONArray(listOf(80.0+it,200.0)) }))
|
||||
.put("head",JSONArray(listOf(0.1,0.2,0.3,1.0,0.0,0.0,0.0)))
|
||||
|
||||
@Test fun preservesPartialBoardCorrespondencesAndHeadPose() {
|
||||
for(count in listOf(12,20,24)) {
|
||||
val restored=CalibrationObservationData.parse(JSONObject(view(count).toString()))
|
||||
assertEquals(count,restored.objects.size)
|
||||
assertEquals(20.0,restored.left.last()[0]-restored.right.last()[0],0.0)
|
||||
assertEquals(SpatialVector(.1f,.2f,.3f),restored.head.position)
|
||||
assertEquals(SpatialRotation(),restored.head.rotation)
|
||||
}
|
||||
}
|
||||
@Test fun rejectsTruncatedOrMismatchedCorrespondences() {
|
||||
assertThrows(IllegalArgumentException::class.java) { CalibrationObservationData.parse(view(11)) }
|
||||
assertThrows(IllegalArgumentException::class.java) { CalibrationObservationData.parse(view(25)) }
|
||||
assertThrows(IllegalArgumentException::class.java) {
|
||||
CalibrationObservationData.parse(view().put("right",view(20).getJSONArray("right")))
|
||||
}
|
||||
assertThrows(IllegalArgumentException::class.java) {
|
||||
CalibrationObservationData.parse(view().also { it.getJSONArray("left").put(0,JSONArray(listOf(1.0))) })
|
||||
}
|
||||
}
|
||||
@Test fun rejectsInvalidHeadRotationAndFloatOverflow() {
|
||||
assertThrows(IllegalStateException::class.java) {
|
||||
CalibrationObservationData.parse(view().put("head",JSONArray(listOf(0,0,0,0,0,0,0))))
|
||||
}
|
||||
assertThrows(IllegalStateException::class.java) {
|
||||
CalibrationObservationData.parse(view().put("head",JSONArray(listOf(1e100,0,0,1,0,0,0))))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,450 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import android.content.Context
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import org.junit.Assert.*
|
||||
import org.junit.After
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.RuntimeEnvironment
|
||||
import org.robolectric.Shadows.shadowOf
|
||||
import org.robolectric.annotation.Config
|
||||
import org.robolectric.annotation.LooperMode
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [28], manifest = Config.NONE)
|
||||
@LooperMode(LooperMode.Mode.PAUSED)
|
||||
class Glasses3dRoutingTest {
|
||||
private val handler = Handler(Looper.getMainLooper())
|
||||
private val commands = mutableListOf<Pair<Int, Boolean>>()
|
||||
private val hardwareMessages = mutableListOf<Int>()
|
||||
private lateinit var stateBefore: GlassesState
|
||||
private lateinit var settingsBefore: GlassesSettings
|
||||
private val supportedModels: List<GlassesModel> =
|
||||
listOf("One", "Lite", "Pro", "Pro 2", "Luma", "Luma Pro", "Luma Cyber", "Luma Ultra", "Beast")
|
||||
.map { VitureProtocol.sdkModel(it)!! } + listOf(
|
||||
RayNeoModel.model(0x1bbb, 0xaf50, "RayNeo Air 4 Pro")!!,
|
||||
RayNeoModel.model(0x3941, 0xaf50, "RayNeo GT")!!,
|
||||
RayNeoModel.model(0x3941, 0xaf50, "RayNeo GT MAX")!!,
|
||||
XrealModel,
|
||||
)
|
||||
private fun field(name: String) = Glasses::class.java.getDeclaredField(name).apply { isAccessible = true }
|
||||
|
||||
@Before fun prepare() {
|
||||
stateBefore = Glasses.state.value
|
||||
settingsBefore = Glasses.settings.value
|
||||
val context = RuntimeEnvironment.getApplication()
|
||||
context.getSharedPreferences("glasses", Context.MODE_PRIVATE).edit().clear().commit()
|
||||
field("app").set(null, context)
|
||||
field("handler").set(null, handler)
|
||||
field("model").set(null, VitureProtocol.model(0x1019, null))
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val state = field("_state").get(null) as MutableStateFlow<GlassesState>
|
||||
state.value = GlassesState(connected = true, controllable = true,
|
||||
displayId = 2, width = 1920, height = 1080)
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val settings = field("_settings").get(null) as MutableStateFlow<GlassesSettings>
|
||||
settings.value = GlassesSettings(gameOnGlasses = false)
|
||||
field("link").set(null, object : GlassesLink {
|
||||
override val hasImu = false
|
||||
override fun send(msgId: Int, payload: ByteArray): Boolean {
|
||||
hardwareMessages += msgId
|
||||
if (msgId == VitureProtocol.MSG_DISPLAY)
|
||||
commands += (payload[0].toInt() and 255) to Glasses.settings.value.gameOnGlasses
|
||||
return true
|
||||
}
|
||||
override fun close() {}
|
||||
})
|
||||
}
|
||||
|
||||
@After fun cleanUp() {
|
||||
handler.removeCallbacksAndMessages(null)
|
||||
field("link").set(null, null)
|
||||
(field("modeState").get(null) as GlassesModeState).apply { manual(); sent(false, 0) }
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val state = field("_state").get(null) as MutableStateFlow<GlassesState>
|
||||
state.value = stateBefore
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val settings = field("_settings").get(null) as MutableStateFlow<GlassesSettings>
|
||||
settings.value = settingsBefore
|
||||
}
|
||||
|
||||
@Test fun lumaJoyConsDefaultOffPersistAndExcludeBareHands() {
|
||||
assertFalse(GlassesSettings().joyConTracking)
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val state = field("_state").get(null) as MutableStateFlow<GlassesState>
|
||||
state.value = state.value.copy(supportsSpatial = true)
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val settings = field("_settings").get(null) as MutableStateFlow<GlassesSettings>
|
||||
Glasses.setJoyConTracking(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertFalse(Glasses.settings.value.joyConTracking)
|
||||
settings.value = settings.value.copy(positionalTracking = true, handControllers = true)
|
||||
Glasses.setJoyConTracking(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(Glasses.settings.value.joyConTracking)
|
||||
assertFalse(Glasses.settings.value.handControllers)
|
||||
val prefs = RuntimeEnvironment.getApplication().getSharedPreferences("glasses", Context.MODE_PRIVATE)
|
||||
assertTrue(prefs.getBoolean("joyConTracking", false))
|
||||
val loaded = Glasses::class.java.getDeclaredMethod("load").apply { isAccessible = true }.invoke(Glasses) as GlassesSettings
|
||||
assertTrue(loaded.joyConTracking)
|
||||
Glasses.setHandControllers(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertFalse(Glasses.settings.value.joyConTracking)
|
||||
assertTrue(Glasses.settings.value.handControllers)
|
||||
SpatialTracking.setControllers(false, false)
|
||||
}
|
||||
|
||||
@Test fun otherGlassesRejectSpatialEnableAndRestartWithoutClosingTheirLink() {
|
||||
val before = Glasses.settings.value
|
||||
val link = field("link").get(null)
|
||||
Glasses.setPositionalTracking(true)
|
||||
Glasses.restartSpatialTracking()
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertEquals(before, Glasses.settings.value)
|
||||
assertSame(link, field("link").get(null))
|
||||
assertTrue(hardwareMessages.isEmpty())
|
||||
}
|
||||
|
||||
@Test fun manual3dSelectsAndSavesGlassesOutputBeforeSwitchingTheDisplay() {
|
||||
Glasses.set3d(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
|
||||
assertEquals(listOf(0x32 to true), commands)
|
||||
assertTrue(Glasses.settings.value.gameOnGlasses)
|
||||
val prefs = RuntimeEnvironment.getApplication().getSharedPreferences("glasses", Context.MODE_PRIVATE)
|
||||
assertTrue(prefs.getBoolean("gameOnGlasses", false))
|
||||
}
|
||||
|
||||
@Test fun nativeThirtyHzIsSavedWithoutSendingAFabricatedHardwareMode() {
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val state = field("_state").get(null) as MutableStateFlow<GlassesState>
|
||||
Glasses.setGameOnGlasses(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
state.value = state.value.copy(supports30Hz = true)
|
||||
|
||||
Glasses.setRefreshHz(30)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertEquals(30, Glasses.settings.value.refreshHz)
|
||||
assertTrue(hardwareMessages.isEmpty())
|
||||
|
||||
state.value = state.value.copy(sbs = true, width = 3840)
|
||||
Glasses.setSbsHz(30)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertEquals(30, Glasses.settings.value.sbsHz)
|
||||
assertTrue(hardwareMessages.isEmpty())
|
||||
val saved = Glasses::class.java.getDeclaredMethod("load").apply { isAccessible = true }
|
||||
.invoke(Glasses) as GlassesSettings
|
||||
assertEquals(30, saved.refreshHz)
|
||||
assertEquals(30, saved.sbsHz)
|
||||
}
|
||||
|
||||
@Test fun unsupportedThirtyHzRequestsLeavePreferencesAndHardwareUnchanged() {
|
||||
val before = Glasses.settings.value
|
||||
Glasses.setRefreshHz(30)
|
||||
Glasses.setSbsHz(30)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertEquals(before, Glasses.settings.value)
|
||||
assertTrue(hardwareMessages.isEmpty())
|
||||
}
|
||||
|
||||
@Test fun automaticSteamVr3dAlsoSelectsGlassesOutput() {
|
||||
Glasses.set3dForVr(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
|
||||
assertEquals(listOf(0x32 to true), commands)
|
||||
assertTrue(Glasses.settings.value.gameOnGlasses)
|
||||
}
|
||||
|
||||
@Test fun returningTo2dKeepsTheGameOnGlasses() {
|
||||
Glasses.set3d(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
Glasses.set3d(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
|
||||
assertEquals(listOf(0x32 to true, 0x34 to true), commands)
|
||||
assertTrue(Glasses.settings.value.gameOnGlasses)
|
||||
}
|
||||
|
||||
@Test fun turningOff3dDoesNotEnableGlassesOutput() {
|
||||
Glasses.set3d(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
|
||||
assertEquals(listOf(0x34 to false), commands)
|
||||
assertFalse(Glasses.settings.value.gameOnGlasses)
|
||||
}
|
||||
|
||||
@Test fun turningOffGlassesOutputRestores2dOnEverySupportedModel() {
|
||||
for (model in supportedModels) {
|
||||
selectModel(model)
|
||||
Glasses.set3dof(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(Glasses.settings.value.screen3dof)
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val state = field("_state").get(null) as MutableStateFlow<GlassesState>
|
||||
state.value = state.value.copy(sbs = true, width = 3840)
|
||||
commands.clear()
|
||||
|
||||
Glasses.setGameOnGlasses(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
|
||||
assertEquals(listOf(model.mode(120, false) to true), commands)
|
||||
assertFalse(Glasses.settings.value.gameOnGlasses)
|
||||
assertFalse(Glasses.settings.value.screen3dof)
|
||||
assertEquals(GlassesSettings.PICTURE_AUTO, Glasses.settings.value.picture3d)
|
||||
val prefs = RuntimeEnvironment.getApplication().getSharedPreferences("glasses", Context.MODE_PRIVATE)
|
||||
assertFalse(prefs.getBoolean("gameOnGlasses", true))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun turningOffGlassesOutputCancelsAnUnconfirmedStereoSwitch() {
|
||||
Glasses.set3d(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertFalse(Glasses.state.value.sbs)
|
||||
assertTrue(Glasses.state.value.switching3d)
|
||||
|
||||
Glasses.setGameOnGlasses(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
|
||||
assertEquals(listOf(0x32 to true, 0x34 to true), commands)
|
||||
assertFalse(Glasses.state.value.switching3d)
|
||||
assertFalse(Glasses.settings.value.gameOnGlasses)
|
||||
}
|
||||
|
||||
@Test fun turningOffGlassesOutputTakesOwnershipFromAutomaticVr() {
|
||||
Glasses.set3dForVr(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
Glasses.setGameOnGlasses(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
Glasses.set3dForVr(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
|
||||
assertEquals(listOf(0x32 to true, 0x34 to true), commands)
|
||||
assertFalse(Glasses.state.value.switching3d)
|
||||
assertFalse(Glasses.settings.value.gameOnGlasses)
|
||||
}
|
||||
|
||||
@Test fun togglingGlassesOutputIn2dDoesNotSendDisplayCommands() {
|
||||
Glasses.setGameOnGlasses(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(Glasses.settings.value.gameOnGlasses)
|
||||
Glasses.setGameOnGlasses(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
|
||||
assertFalse(Glasses.settings.value.gameOnGlasses)
|
||||
assertTrue(hardwareMessages.isEmpty())
|
||||
}
|
||||
|
||||
@Test fun turningOffGlassesOutputDisablesVirtualScreenAndSavesTheChoice() {
|
||||
selectModel(supportedModels.first())
|
||||
Glasses.set3dof(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
Glasses.setGameOnGlasses(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(Glasses.settings.value.screen3dof)
|
||||
|
||||
Glasses.setGameOnGlasses(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
|
||||
assertFalse(Glasses.settings.value.screen3dof)
|
||||
assertEquals(GlassesSettings.PICTURE_AUTO, Glasses.settings.value.picture3d)
|
||||
val saved = Glasses::class.java.getDeclaredMethod("load").apply { isAccessible = true }
|
||||
.invoke(Glasses) as GlassesSettings
|
||||
assertFalse(saved.gameOnGlasses)
|
||||
assertFalse(saved.screen3dof)
|
||||
assertEquals(GlassesSettings.PICTURE_AUTO, saved.picture3d)
|
||||
|
||||
Glasses.setGameOnGlasses(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertFalse(Glasses.settings.value.screen3dof)
|
||||
assertTrue(hardwareMessages.isEmpty())
|
||||
}
|
||||
|
||||
@Test fun turningOffGlassesOutputDisablesVirtualScreenWithoutDeviceControl() {
|
||||
selectModel(supportedModels.first())
|
||||
Glasses.set3dof(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(Glasses.settings.value.screen3dof)
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val state = field("_state").get(null) as MutableStateFlow<GlassesState>
|
||||
state.value = state.value.copy(connected = false, supportsScreen3dof = false)
|
||||
|
||||
Glasses.setGameOnGlasses(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
|
||||
assertFalse(Glasses.settings.value.gameOnGlasses)
|
||||
assertFalse(Glasses.settings.value.screen3dof)
|
||||
assertEquals(GlassesSettings.PICTURE_AUTO, Glasses.settings.value.picture3d)
|
||||
assertTrue(hardwareMessages.isEmpty())
|
||||
}
|
||||
|
||||
@Test fun enabling3dofRoutesFlatContentWithoutSendingAStereoCommandAndSurvivesReload() {
|
||||
for (model in supportedModels) {
|
||||
selectModel(model)
|
||||
Glasses.set3dof(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
|
||||
assertTrue(hardwareMessages.isEmpty())
|
||||
assertFalse(Glasses.state.value.sbs)
|
||||
assertFalse(Glasses.state.value.switching3d)
|
||||
assertTrue(Glasses.settings.value.screen3dof)
|
||||
assertTrue(Glasses.settings.value.gameOnGlasses)
|
||||
val saved = Glasses::class.java.getDeclaredMethod("load").apply { isAccessible = true }
|
||||
.invoke(Glasses) as GlassesSettings
|
||||
assertTrue(saved.screen3dof)
|
||||
assertTrue(saved.gameOnGlasses)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun stereoAnd3dofCanBeToggledIndependentlyOnEverySupportedModel() {
|
||||
for (model in supportedModels) {
|
||||
selectModel(model)
|
||||
Glasses.set3dof(true)
|
||||
Glasses.set3d(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(Glasses.settings.value.screen3dof)
|
||||
|
||||
Glasses.set3d(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(Glasses.settings.value.screen3dof)
|
||||
assertEquals(listOf(model.mode(60, true) to true, model.mode(120, false) to true), commands)
|
||||
|
||||
commands.clear()
|
||||
hardwareMessages.clear()
|
||||
Glasses.set3dof(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(hardwareMessages.isEmpty())
|
||||
assertFalse(Glasses.settings.value.screen3dof)
|
||||
assertEquals(GlassesSettings.PICTURE_AUTO, Glasses.settings.value.picture3d)
|
||||
assertTrue(Glasses.settings.value.gameOnGlasses)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun enabling3dofWithoutHeadTrackingSupportLeavesSettingsUnchanged() {
|
||||
val before = Glasses.settings.value
|
||||
Glasses.set3dof(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertEquals(before, Glasses.settings.value)
|
||||
assertTrue(hardwareMessages.isEmpty())
|
||||
}
|
||||
|
||||
@Test fun resolutionsPersistIndependentlyAndOnlyTheActiveProfileChangesHardware() {
|
||||
selectModel(VitureProtocol.sdkModel("Luma Ultra")!!)
|
||||
Glasses.setResolution(GlassesDisplayProfile.THREE_D, "1920x1080")
|
||||
Glasses.setResolution(GlassesDisplayProfile.VR, "1920x1200")
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(hardwareMessages.isEmpty())
|
||||
|
||||
Glasses.setResolution(GlassesDisplayProfile.TWO_D, "1920x1080")
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertEquals(listOf(0x34 to false), commands)
|
||||
assertEquals(120, Glasses.settings.value.refreshHz)
|
||||
assertEquals(60, Glasses.settings.value.sbsHz)
|
||||
val saved = Glasses::class.java.getDeclaredMethod("load").apply { isAccessible = true }
|
||||
.invoke(Glasses) as GlassesSettings
|
||||
assertEquals("1920x1080", saved.resolution2d)
|
||||
assertEquals("1920x1080", saved.resolution3d)
|
||||
assertEquals("1920x1200", saved.resolutionVr)
|
||||
assertEquals(listOf(VitureProtocol.MSG_DISPLAY), hardwareMessages)
|
||||
}
|
||||
|
||||
@Test fun vrResolutionIsAppliedAndTheOrdinaryResolutionIsRestoredAfterStopping() {
|
||||
selectModel(VitureProtocol.sdkModel("Luma Ultra")!!)
|
||||
Glasses.setResolution(GlassesDisplayProfile.TWO_D, "1920x1080")
|
||||
Glasses.setResolution(GlassesDisplayProfile.VR, "1920x1200")
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
commands.clear()
|
||||
Glasses.setVrActive(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(Glasses.state.value.vrActive)
|
||||
assertEquals(listOf(0x44 to false), commands)
|
||||
Glasses.setVrActive(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertFalse(Glasses.state.value.vrActive)
|
||||
assertEquals(listOf(0x44 to false, 0x34 to false), commands)
|
||||
}
|
||||
|
||||
@Test fun vrResolutionUsesStereoCommandsAndRestoresThePreVrLayoutOnce() {
|
||||
selectModel(VitureProtocol.sdkModel("Luma Ultra")!!)
|
||||
Glasses.setGameOnGlasses(true)
|
||||
Glasses.setAuto3d(true)
|
||||
Glasses.setResolution(GlassesDisplayProfile.VR, "1920x1080")
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
Glasses.setVrActive(true)
|
||||
Glasses.set3dForVr(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertEquals(listOf(0x32 to true), commands)
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val state = field("_state").get(null) as MutableStateFlow<GlassesState>
|
||||
state.value = state.value.copy(sbs = true, width = 3840, switching3d = false)
|
||||
(field("modeState").get(null) as GlassesModeState).observe(true, 0)
|
||||
|
||||
Glasses.setSbsHz(90)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertEquals(0x35 to true, commands.last())
|
||||
Glasses.setVrActive(false)
|
||||
Glasses.set3dForVr(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertEquals(listOf(0x32 to true, 0x35 to true, 0x44 to true), commands)
|
||||
}
|
||||
|
||||
@Test fun invalidResolutionCannotChangePreferencesOrSendDeviceCommands() {
|
||||
selectModel(VitureProtocol.sdkModel("Pro")!!)
|
||||
val before = Glasses.settings.value
|
||||
for (value in listOf("1920x1200", "3840x1080", "-1x1080", "unknown"))
|
||||
Glasses.setResolution(GlassesDisplayProfile.TWO_D, value)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertEquals(before, Glasses.settings.value)
|
||||
assertTrue(hardwareMessages.isEmpty())
|
||||
}
|
||||
|
||||
@Test fun startingVrDuringAStereoSwitchDoesNotSendAFlatMode() {
|
||||
selectModel(VitureProtocol.sdkModel("Luma Ultra")!!)
|
||||
Glasses.setResolution(GlassesDisplayProfile.VR, "1920x1080")
|
||||
Glasses.set3d(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(Glasses.state.value.switching3d)
|
||||
Glasses.setVrActive(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertEquals(listOf(0x42 to true, 0x32 to true), commands)
|
||||
}
|
||||
|
||||
@Test fun reconnectRestoresASavedResolutionEvenWhenRefreshAlreadyMatches() {
|
||||
selectModel(VitureProtocol.sdkModel("Luma Ultra")!!)
|
||||
Glasses.setResolution(GlassesDisplayProfile.TWO_D, "1920x1080")
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val state = field("_state").get(null) as MutableStateFlow<GlassesState>
|
||||
state.value = state.value.copy(width = 1920, height = 1200, hz = 120f)
|
||||
field("glassesMode").setInt(null, 0)
|
||||
field("autoModeSent").setBoolean(null, false)
|
||||
field("lastModeSentAt").setLong(null, -10_000L)
|
||||
commands.clear()
|
||||
Glasses::class.java.getDeclaredMethod("applyMode", Boolean::class.javaPrimitiveType)
|
||||
.apply { isAccessible = true }.invoke(Glasses, false)
|
||||
assertEquals(listOf(0x34 to false), commands)
|
||||
}
|
||||
|
||||
@Test fun defaultVrProfileDoesNotSendExtraDisplayCommands() {
|
||||
selectModel(VitureProtocol.sdkModel("Luma Ultra")!!)
|
||||
Glasses.setVrActive(true)
|
||||
Glasses.setVrActive(false)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(hardwareMessages.isEmpty())
|
||||
}
|
||||
|
||||
private fun selectModel(model: GlassesModel) {
|
||||
field("model").set(null, model)
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val state = field("_state").get(null) as MutableStateFlow<GlassesState>
|
||||
state.value = state.value.copy(model = model.name, supportsScreen3dof = true, resolutions = model.resolutions)
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val settings = field("_settings").get(null) as MutableStateFlow<GlassesSettings>
|
||||
settings.value = GlassesSettings(gameOnGlasses = false, headTracking = false)
|
||||
assertFalse(settings.value.screen3dof)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
|
||||
class GlassesDisplayModesTest {
|
||||
private val fullHd = GlassesResolution(1920, 1080)
|
||||
private val tall = GlassesResolution(1920, 1200)
|
||||
private val ultra = VitureProtocol.sdkModel("Luma Ultra")!!
|
||||
private val state = GlassesState(resolutions = ultra.resolutions)
|
||||
|
||||
@Test fun separateProfilesRetainTheirOwnResolutions() {
|
||||
val settings = GlassesSettings(resolution2d = fullHd.key, resolution3d = tall.key, resolutionVr = fullHd.key)
|
||||
assertEquals(fullHd, GlassesDisplayModes.selected(settings, state))
|
||||
assertEquals(tall, GlassesDisplayModes.selected(settings, state.copy(sbs = true)))
|
||||
for (stereo in listOf(false, true))
|
||||
assertEquals(fullHd, GlassesDisplayModes.selected(settings, state.copy(sbs = stereo, vrActive = true)))
|
||||
}
|
||||
|
||||
@Test fun automaticVrInheritsTheActiveLayoutAndDefaultsKeepNativeBehavior() {
|
||||
val settings = GlassesSettings(resolution2d = fullHd.key, resolution3d = tall.key)
|
||||
assertEquals(fullHd, GlassesDisplayModes.selected(settings, state.copy(vrActive = true)))
|
||||
assertEquals(tall, GlassesDisplayModes.selected(settings, state.copy(sbs = true, vrActive = true)))
|
||||
assertNull(GlassesDisplayModes.selected(GlassesSettings(), state))
|
||||
assertNull(GlassesDisplayModes.selected(GlassesSettings(), state.copy(sbs = true, vrActive = true)))
|
||||
}
|
||||
|
||||
@Test fun anotherHeadsetDoesNotReceiveAnUnsupportedSavedResolution() {
|
||||
val settings = GlassesSettings(resolution2d = tall.key, resolutionVr = tall.key)
|
||||
assertNull(GlassesDisplayModes.selected(settings, state.copy(resolutions = listOf(fullHd))))
|
||||
assertNull(GlassesDisplayModes.selected(settings, state.copy(resolutions = emptyList(), vrActive = true)))
|
||||
assertEquals(tall, GlassesDisplayModes.selected(settings, state))
|
||||
}
|
||||
|
||||
@Test fun ultraResolutionsMapToVendorCommandsAtEverySupportedRefresh() {
|
||||
for ((hz, code) in listOf(60 to 0x31, 90 to 0x33, 120 to 0x34)) {
|
||||
assertEquals(code, ultra.mode(hz, false, fullHd))
|
||||
assertEquals(code + 0x10, ultra.mode(hz, false, tall))
|
||||
}
|
||||
for ((hz, code) in listOf(60 to 0x32, 90 to 0x35)) {
|
||||
assertEquals(code, ultra.mode(hz, true, fullHd))
|
||||
assertEquals(code + 0x10, ultra.mode(hz, true, tall))
|
||||
}
|
||||
assertEquals(0x41, ultra.mode(30, false, tall))
|
||||
assertEquals(0x42, ultra.mode(30, true, tall))
|
||||
}
|
||||
|
||||
@Test fun olderModelsKeepTheirNativeResolutionAndStereoRateLimits() {
|
||||
for (name in listOf("One", "Pro", "Pro 2")) {
|
||||
val model = VitureProtocol.sdkModel(name)!!
|
||||
assertEquals(listOf(fullHd), model.resolutions)
|
||||
assertEquals(0x34, model.mode(120, false, tall))
|
||||
assertEquals(0x32, model.mode(90, true, tall))
|
||||
}
|
||||
for (name in listOf("Luma", "Luma Pro", "Luma Ultra", "Beast")) {
|
||||
val model = VitureProtocol.sdkModel(name)!!
|
||||
assertEquals(listOf(fullHd, tall), model.resolutions)
|
||||
assertEquals(0x44, model.mode(120, false))
|
||||
assertEquals(if (model.sbs90) 0x45 else 0x42, model.mode(90, true))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,149 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import android.app.Activity
|
||||
import android.app.Application
|
||||
import android.app.Dialog
|
||||
import android.app.Presentation
|
||||
import android.graphics.SurfaceTexture
|
||||
import android.hardware.display.DisplayManager
|
||||
import android.view.Choreographer
|
||||
import android.view.Surface
|
||||
import android.view.View
|
||||
import android.view.WindowManager
|
||||
import android.widget.FrameLayout
|
||||
import org.junit.After
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.Robolectric
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.android.controller.ActivityController
|
||||
import org.robolectric.annotation.Config
|
||||
import org.robolectric.annotation.LooperMode
|
||||
import org.robolectric.shadows.ShadowDisplayManager
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [29], manifest = Config.NONE, application = Application::class)
|
||||
@LooperMode(LooperMode.Mode.PAUSED)
|
||||
class GlassesMenuCaptureTest {
|
||||
private lateinit var controller: ActivityController<Activity>
|
||||
private lateinit var activity: Activity
|
||||
private val dialogs = mutableListOf<Dialog>()
|
||||
|
||||
@Before fun setUp() {
|
||||
controller = Robolectric.buildActivity(Activity::class.java).setup().visible()
|
||||
activity = controller.get()
|
||||
activity.window.decorView.layout(0, 0, 1920, 1080)
|
||||
}
|
||||
|
||||
@After fun tearDown() {
|
||||
dialogs.forEach { it.dismiss() }
|
||||
controller.pause().stop().destroy()
|
||||
}
|
||||
|
||||
@Test fun onlyTheActivityAndItsOwnDialogAreIncludedOnce() {
|
||||
val own = dialog(activity)
|
||||
val otherController = Robolectric.buildActivity(Activity::class.java).setup().visible()
|
||||
val other = otherController.get()
|
||||
val otherDialog = dialog(other)
|
||||
try {
|
||||
val decor = activity.window.decorView
|
||||
val roots = GlassesMenuCapture.captureRoots(activity,
|
||||
listOf(other.window.decorView, own, otherDialog, decor, own))
|
||||
assertEquals(listOf(decor, own), roots)
|
||||
} finally {
|
||||
dialogs.removeAll { if (it.ownerActivity === other) { it.dismiss(); true } else false }
|
||||
otherController.pause().stop().destroy()
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun secureActivityProducesNoRootsAndSecureDialogsAreExcluded() {
|
||||
val secure = dialog(activity)
|
||||
val params = secure.layoutParams as WindowManager.LayoutParams
|
||||
params.flags = params.flags or WindowManager.LayoutParams.FLAG_SECURE
|
||||
assertEquals(listOf(activity.window.decorView), GlassesMenuCapture.captureRoots(activity, listOf(secure)))
|
||||
|
||||
activity.window.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
|
||||
assertTrue(GlassesMenuCapture.captureRoots(activity, listOf(secure)).isEmpty())
|
||||
activity.window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE)
|
||||
assertEquals(listOf(activity.window.decorView), GlassesMenuCapture.captureRoots(activity, listOf(secure)))
|
||||
}
|
||||
|
||||
@Test fun systemWindowsAndPresentationsOnOtherDisplaysAreExcluded() {
|
||||
val own = dialog(activity)
|
||||
(own.layoutParams as WindowManager.LayoutParams).type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
|
||||
val displayId = ShadowDisplayManager.addDisplay("w1920dp-h1080dp")
|
||||
val display = activity.getSystemService(DisplayManager::class.java).getDisplay(displayId)
|
||||
val presentation = Presentation(activity, display).apply {
|
||||
setContentView(FrameLayout(context))
|
||||
show()
|
||||
}.also(dialogs::add)
|
||||
try {
|
||||
assertEquals(listOf(activity.window.decorView), GlassesMenuCapture.captureRoots(activity,
|
||||
listOf(own, presentation.window!!.decorView)))
|
||||
} finally {
|
||||
presentation.dismiss()
|
||||
dialogs.remove(presentation)
|
||||
ShadowDisplayManager.removeDisplay(displayId)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
@Config(sdk = [26])
|
||||
fun olderAndroidCapturesOnlyTheActivityDecor() {
|
||||
val own = dialog(activity)
|
||||
assertEquals(listOf(activity.window.decorView), GlassesMenuCapture.captureRoots(activity, listOf(own)))
|
||||
}
|
||||
|
||||
@Test fun captureSizesPreserveOrientationAndNeverUpscale() {
|
||||
assertEquals(1920 to 1080, GlassesMenuCapture.captureSize(3840, 2160))
|
||||
assertEquals(1080 to 1920, GlassesMenuCapture.captureSize(2160, 3840))
|
||||
assertEquals(1200 to 1800, GlassesMenuCapture.captureSize(1200, 1800))
|
||||
val fold = GlassesMenuCapture.captureSize(2152, 1812)!!
|
||||
assertEquals(1920, fold.first)
|
||||
assertEquals(2152.0 / 1812.0, fold.first.toDouble() / fold.second, 0.001)
|
||||
assertNull(GlassesMenuCapture.captureSize(0, 1000))
|
||||
assertNull(GlassesMenuCapture.captureSize(1000, -1))
|
||||
}
|
||||
|
||||
@Test fun repeatedSurfaceFailureStopsOnceAndDoesNotRetryAfterStop() {
|
||||
var sizes = 0
|
||||
var failures = 0
|
||||
val capture = GlassesMenuCapture(activity, { _, _ -> sizes++ }, { failures++ })
|
||||
val input = SurfaceTexture(0)
|
||||
val target = Surface(input)
|
||||
target.release()
|
||||
try {
|
||||
capture.attach(input, target)
|
||||
capture.start()
|
||||
for (time in listOf(1L, 33_333_335L, 66_666_669L, 100_000_003L)) {
|
||||
Choreographer.getInstance().removeFrameCallback(capture)
|
||||
capture.doFrame(time)
|
||||
}
|
||||
assertEquals(1, failures)
|
||||
assertEquals(0, sizes)
|
||||
assertFalse(pending(capture))
|
||||
} finally {
|
||||
capture.stop()
|
||||
input.release()
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun stoppingRejectsAnAlreadyDispatchedFrameWithoutRescheduling() {
|
||||
val capture = GlassesMenuCapture(activity, { _, _ -> fail("Stopped capture changed its size") })
|
||||
capture.start()
|
||||
capture.stop()
|
||||
capture.doFrame(1L)
|
||||
assertFalse(pending(capture))
|
||||
}
|
||||
|
||||
private fun dialog(owner: Activity): View = Dialog(owner).apply {
|
||||
setOwnerActivity(owner)
|
||||
setContentView(FrameLayout(context))
|
||||
show()
|
||||
}.also(dialogs::add).window!!.decorView
|
||||
|
||||
private fun pending(capture: GlassesMenuCapture): Boolean =
|
||||
GlassesMenuCapture::class.java.getDeclaredField("framePending").apply { isAccessible = true }.getBoolean(capture)
|
||||
}
|
||||
@@ -0,0 +1,340 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import android.app.Activity
|
||||
import android.app.Application
|
||||
import android.hardware.display.DisplayManager
|
||||
import android.view.Display
|
||||
import android.view.WindowManager
|
||||
import com.droiddeck.launcher.QuestXrActivity
|
||||
import com.droiddeck.launcher.SessionActivity
|
||||
import org.junit.After
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.Robolectric
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.RuntimeEnvironment
|
||||
import org.robolectric.android.controller.ActivityController
|
||||
import org.robolectric.annotation.Config
|
||||
import org.robolectric.annotation.LooperMode
|
||||
import org.robolectric.shadows.ShadowDisplayManager
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [28], application = Application::class, manifest = Config.NONE)
|
||||
@LooperMode(LooperMode.Mode.PAUSED)
|
||||
class GlassesMenuControllerTest {
|
||||
private lateinit var owner: Activity
|
||||
private lateinit var ownerLifecycle: ActivityController<Activity>
|
||||
private lateinit var external: Display
|
||||
private lateinit var menus: GlassesMenuController
|
||||
private val displays = mutableListOf<Int>()
|
||||
private val outputs = mutableListOf<FakeOutput>()
|
||||
private val subscriptions = mutableListOf<Boolean>()
|
||||
private val scheduled = ArrayDeque<() -> Unit>()
|
||||
private var target: Display? = null
|
||||
private var creationError: RuntimeException? = null
|
||||
private var onCreateOutput: (FakeOutput) -> Unit = {}
|
||||
private val saved = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN,
|
||||
headTracking = true, screenWidthDm = 35, screenDistanceDm = 45)
|
||||
private lateinit var glasses: GlassesState
|
||||
|
||||
@Before fun setUp() {
|
||||
ownerLifecycle = Robolectric.buildActivity(Activity::class.java).setup()
|
||||
owner = ownerLifecycle.get()
|
||||
external = addDisplay()
|
||||
target = external
|
||||
glasses = GlassesState(present = true, connected = true, controllable = true,
|
||||
supportsScreen3dof = true, displayId = external.displayId, width = 1920, height = 1080)
|
||||
menus = GlassesMenuController(GlassesMenuPose(spatialEnabled = { false }),
|
||||
display = { target }, observe = { subscriptions += it },
|
||||
create = { activity, display, failure ->
|
||||
creationError?.let { throw it }
|
||||
FakeOutput(activity, display, failure).also {
|
||||
outputs += it
|
||||
onCreateOutput(it)
|
||||
}
|
||||
}, schedule = { scheduled.addLast(it) })
|
||||
menus.update(glasses, saved)
|
||||
}
|
||||
|
||||
@After fun tearDown() {
|
||||
menus.pause(owner)
|
||||
ownerLifecycle.pause().stop().destroy()
|
||||
displays.forEach(ShadowDisplayManager::removeDisplay)
|
||||
}
|
||||
|
||||
@Test fun menusStartOnlyForSupportedControlledExternalOutputWithTrackingSelected() {
|
||||
val invalid = listOf(
|
||||
glasses.copy(connected = false) to saved,
|
||||
glasses.copy(controllable = false) to saved,
|
||||
glasses.copy(supportsScreen3dof = false) to saved,
|
||||
glasses.copy(noSignal = true) to saved,
|
||||
glasses.copy(displayId = Display.INVALID_DISPLAY) to saved,
|
||||
glasses to saved.copy(gameOnGlasses = false),
|
||||
glasses to saved.copy(headTracking = false),
|
||||
glasses to saved.copy(picture3d = GlassesSettings.PICTURE_AUTO),
|
||||
)
|
||||
for ((state, preferences) in invalid) {
|
||||
menus.update(state, preferences)
|
||||
menus.resume(owner)
|
||||
assertTrue(outputs.isEmpty())
|
||||
assertTrue(subscriptions.isEmpty())
|
||||
}
|
||||
menus.update(glasses, saved)
|
||||
assertEquals(1, outputs.size)
|
||||
assertEquals(listOf(true), subscriptions)
|
||||
assertEquals(1, outputs.single().shows)
|
||||
assertEquals(saved, outputs.single().settings)
|
||||
}
|
||||
|
||||
@Test fun absentDisplayAndThePhoneDisplayNeverCreateAnOutput() {
|
||||
target = null
|
||||
menus.resume(owner)
|
||||
target = owner.windowManager.defaultDisplay
|
||||
menus.update(glasses, saved)
|
||||
assertTrue(outputs.isEmpty())
|
||||
assertTrue(subscriptions.isEmpty())
|
||||
target = external
|
||||
menus.update(glasses, saved)
|
||||
assertEquals(1, outputs.size)
|
||||
}
|
||||
|
||||
@Test fun sessionContentIsExcludedUntilItsMenuIsVisibleAndStalePauseCannotCloseNewOwner() {
|
||||
menus.resume(owner)
|
||||
val first = outputs.single()
|
||||
val session = Robolectric.buildActivity(SessionActivity::class.java).get()
|
||||
menus.resume(session)
|
||||
assertEquals(1, first.closes)
|
||||
assertEquals(1, outputs.size)
|
||||
|
||||
menus.setSessionMenuVisible(session, true)
|
||||
val overlay = outputs.last()
|
||||
assertSame(session, overlay.owner)
|
||||
assertEquals(2, outputs.size)
|
||||
menus.setSessionMenuVisible(session, false)
|
||||
assertEquals(1, overlay.closes)
|
||||
|
||||
menus.resume(owner)
|
||||
val latest = outputs.last()
|
||||
menus.pause(session)
|
||||
menus.setSessionMenuVisible(session, true)
|
||||
assertEquals(0, latest.closes)
|
||||
assertEquals(3, outputs.size)
|
||||
}
|
||||
|
||||
@Test fun pauseReleasesSubscriptionAndLateFailureCannotCloseAReplacement() {
|
||||
menus.resume(owner)
|
||||
val old = outputs.single()
|
||||
menus.pause(owner)
|
||||
menus.pause(owner)
|
||||
assertEquals(1, old.closes)
|
||||
assertEquals(listOf(true, false), subscriptions)
|
||||
|
||||
menus.resume(owner)
|
||||
val current = outputs.last()
|
||||
old.fail(IllegalStateException("late GL callback"))
|
||||
assertEquals(0, current.closes)
|
||||
assertEquals(2, outputs.size)
|
||||
menus.pause(owner)
|
||||
assertEquals(1, current.closes)
|
||||
assertFalse(subscriptions.last())
|
||||
}
|
||||
|
||||
@Test fun destroyedActivityCannotRecreateItsOutputAfterCleanup() {
|
||||
val lifecycle = Robolectric.buildActivity(Activity::class.java).setup()
|
||||
val destroyed = lifecycle.get()
|
||||
menus.resume(destroyed)
|
||||
val output = outputs.single()
|
||||
lifecycle.pause().stop().destroy()
|
||||
menus.pause(destroyed)
|
||||
menus.resume(destroyed)
|
||||
assertEquals(1, output.closes)
|
||||
assertEquals(1, outputs.size)
|
||||
assertFalse(subscriptions.last())
|
||||
menus.pause(destroyed)
|
||||
}
|
||||
|
||||
@Test fun secureFinishingAndImmersiveQuestActivitiesCannotBeCaptured() {
|
||||
owner.window.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
|
||||
menus.resume(owner)
|
||||
assertTrue(outputs.isEmpty())
|
||||
owner.window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE)
|
||||
val quest = Robolectric.buildActivity(QuestXrActivity::class.java).get()
|
||||
menus.resume(quest)
|
||||
assertTrue(outputs.isEmpty())
|
||||
owner.finish()
|
||||
menus.resume(owner)
|
||||
assertTrue(outputs.isEmpty())
|
||||
}
|
||||
|
||||
@Test fun settingsReconfigureTheSameOutputAndDisablingTrackingClosesIt() {
|
||||
menus.resume(owner)
|
||||
val output = outputs.single()
|
||||
val changed = saved.copy(screenWidthDm = 50, screenDistanceDm = 60, positionalTracking = true)
|
||||
menus.update(glasses.copy(sbs = true), changed)
|
||||
assertEquals(1, outputs.size)
|
||||
assertEquals(2, output.configurations)
|
||||
assertEquals(changed, output.settings)
|
||||
assertTrue(output.state!!.sbs)
|
||||
assertEquals(listOf(true), subscriptions)
|
||||
|
||||
menus.update(glasses, changed.copy(headTracking = false))
|
||||
assertEquals(1, output.closes)
|
||||
assertFalse(subscriptions.last())
|
||||
menus.update(glasses, changed)
|
||||
assertEquals(2, outputs.size)
|
||||
assertTrue(subscriptions.last())
|
||||
}
|
||||
|
||||
@Test fun displayRemovalAndReplacementCloseOldOutputAndRebindOnlyTheCurrentDisplay() {
|
||||
menus.resume(owner)
|
||||
val old = outputs.single()
|
||||
target = null
|
||||
menus.update(glasses.copy(displayId = Display.INVALID_DISPLAY), saved)
|
||||
assertEquals(1, old.closes)
|
||||
assertFalse(subscriptions.last())
|
||||
|
||||
target = addDisplay()
|
||||
menus.update(glasses.copy(displayId = target!!.displayId), saved)
|
||||
assertEquals(2, outputs.size)
|
||||
assertSame(target, outputs.last().display)
|
||||
old.fail(IllegalStateException("removed display"))
|
||||
assertEquals(0, outputs.last().closes)
|
||||
}
|
||||
|
||||
@Test fun creationFailureIsLatchedUntilPreferencesChangeWithoutSubscribing() {
|
||||
creationError = IllegalStateException("no EGL display")
|
||||
menus.resume(owner)
|
||||
assertTrue(outputs.isEmpty())
|
||||
assertTrue(subscriptions.isEmpty())
|
||||
creationError = null
|
||||
menus.update(glasses, saved)
|
||||
assertTrue(outputs.isEmpty())
|
||||
menus.update(glasses, saved.copy(screenWidthDm = 40))
|
||||
assertEquals(1, outputs.size)
|
||||
assertTrue(subscriptions.last())
|
||||
}
|
||||
|
||||
@Test fun configureAndShowExceptionsReleaseOutputAndDoNotEscapeUpdates() {
|
||||
onCreateOutput = { it.showError = IllegalStateException("window removed") }
|
||||
menus.resume(owner)
|
||||
assertEquals(1, outputs.single().closes)
|
||||
assertEquals(listOf(true, false), subscriptions)
|
||||
|
||||
onCreateOutput = {}
|
||||
menus.update(glasses, saved.copy(screenWidthDm = 40))
|
||||
val next = outputs.last()
|
||||
next.onConfigure = { throw IllegalStateException("surface lost") }
|
||||
menus.update(glasses, saved)
|
||||
assertEquals(1, next.closes)
|
||||
assertFalse(subscriptions.last())
|
||||
menus.update(glasses, saved)
|
||||
assertEquals(2, outputs.size)
|
||||
}
|
||||
|
||||
@Test fun synchronousFactoryOrConfigureFailureCannotShowOrSubscribeAClosedOutput() {
|
||||
onCreateOutput = { it.fail(IllegalStateException("creation callback")) }
|
||||
menus.resume(owner)
|
||||
assertEquals(0, outputs.single().shows)
|
||||
assertEquals(1, outputs.single().closes)
|
||||
assertFalse(subscriptions.contains(true))
|
||||
|
||||
onCreateOutput = { output -> output.onConfigure = { output.fail(IllegalStateException("configure callback")) } }
|
||||
menus.update(glasses, saved.copy(screenWidthDm = 40))
|
||||
assertEquals(2, outputs.size)
|
||||
assertEquals(0, outputs.last().shows)
|
||||
assertEquals(1, outputs.last().closes)
|
||||
assertFalse(subscriptions.contains(true))
|
||||
}
|
||||
|
||||
@Test fun closeFailureStillReleasesObserverAndDoesNotBlockTheNextResume() {
|
||||
menus.resume(owner)
|
||||
outputs.single().closeError = IllegalStateException("already destroyed surface")
|
||||
menus.pause(owner)
|
||||
assertFalse(subscriptions.last())
|
||||
menus.resume(owner)
|
||||
assertEquals(2, outputs.size)
|
||||
assertEquals(1, outputs.last().shows)
|
||||
}
|
||||
|
||||
@Test fun unexpectedDismissalGetsOneScheduledRetryAndStopsAfterASecondFailure() {
|
||||
menus.resume(owner)
|
||||
val old = outputs.single()
|
||||
old.fail(GlassesMenuDisplayStopped())
|
||||
assertEquals(1, old.closes)
|
||||
assertFalse(subscriptions.last())
|
||||
assertEquals(1, scheduled.size)
|
||||
assertEquals(1, outputs.size)
|
||||
|
||||
scheduled.removeFirst().invoke()
|
||||
assertEquals(2, outputs.size)
|
||||
assertTrue(subscriptions.last())
|
||||
outputs.last().fail(GlassesMenuDisplayStopped())
|
||||
assertTrue(scheduled.isEmpty())
|
||||
assertFalse(subscriptions.last())
|
||||
menus.update(glasses, saved)
|
||||
assertEquals(2, outputs.size)
|
||||
|
||||
menus.update(glasses, saved.copy(screenWidthDm = 40))
|
||||
assertEquals(3, outputs.size)
|
||||
outputs.last().fail(GlassesMenuDisplayStopped())
|
||||
assertEquals(1, scheduled.size)
|
||||
}
|
||||
|
||||
@Test fun scheduledDismissalRecoveryCannotReopenAfterPauseOrReplaceANewerOutput() {
|
||||
menus.resume(owner)
|
||||
outputs.single().fail(GlassesMenuDisplayStopped())
|
||||
menus.pause(owner)
|
||||
scheduled.removeFirst().invoke()
|
||||
assertEquals(1, outputs.size)
|
||||
assertFalse(subscriptions.last())
|
||||
|
||||
menus.resume(owner)
|
||||
outputs.last().fail(GlassesMenuDisplayStopped())
|
||||
menus.pause(owner)
|
||||
menus.resume(owner)
|
||||
val replacement = outputs.last()
|
||||
scheduled.removeFirst().invoke()
|
||||
assertEquals(3, outputs.size)
|
||||
assertEquals(0, replacement.closes)
|
||||
assertTrue(subscriptions.last())
|
||||
}
|
||||
|
||||
@Test fun displayResizeAllowsRetryAfterARealRendererFailureWithoutRetryingEveryStateUpdate() {
|
||||
menus.resume(owner)
|
||||
outputs.single().fail(IllegalStateException("old surface size"))
|
||||
assertTrue(scheduled.isEmpty())
|
||||
menus.update(glasses.copy(tracking = true), saved)
|
||||
assertEquals(1, outputs.size)
|
||||
menus.update(glasses.copy(width = 3840, sbs = true), saved)
|
||||
assertEquals(2, outputs.size)
|
||||
assertEquals(3840, outputs.last().state!!.width)
|
||||
assertTrue(subscriptions.last())
|
||||
}
|
||||
|
||||
private fun addDisplay(): Display {
|
||||
val id = ShadowDisplayManager.addDisplay("w1920dp-h1080dp")
|
||||
displays += id
|
||||
return RuntimeEnvironment.getApplication().getSystemService(DisplayManager::class.java).getDisplay(id)
|
||||
}
|
||||
|
||||
private class FakeOutput(val owner: Activity, val display: Display, val fail: (Throwable) -> Unit) : GlassesMenuController.Output {
|
||||
var configurations = 0
|
||||
var shows = 0
|
||||
var closes = 0
|
||||
var state: GlassesState? = null
|
||||
var settings: GlassesSettings? = null
|
||||
var onConfigure: () -> Unit = {}
|
||||
var showError: RuntimeException? = null
|
||||
var closeError: RuntimeException? = null
|
||||
override fun configure(state: GlassesState, settings: GlassesSettings) {
|
||||
configurations++
|
||||
this.state = state
|
||||
this.settings = settings
|
||||
onConfigure()
|
||||
}
|
||||
override fun show() { shows++; showError?.let { throw it } }
|
||||
override fun close() { closes++; closeError?.let { throw it } }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,142 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import com.droiddeck.launcher.gpu.HeadPose
|
||||
import org.junit.Assert.assertArrayEquals
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
class GlassesMenuPoseTest {
|
||||
private val time = 1_000_000_000L
|
||||
|
||||
@Test fun firstFreshGlassesPoseCentersTheScreenInAllThreeAxes() {
|
||||
val pose = GlassesMenuPose(spatialEnabled = { false })
|
||||
pose.onPose(0.2f, -0.3f, 0.1f, 0.9f, time)
|
||||
|
||||
val frame = pose.snapshot(time)
|
||||
|
||||
assertTrue(frame.valid)
|
||||
assertArrayEquals(HeadPose.IDENTITY, frame.rotation, 1e-5f)
|
||||
assertArrayEquals(FloatArray(3), frame.position, 0f)
|
||||
}
|
||||
|
||||
@Test fun pageConfigurationPreservesTheThreeDofAnchorUntilExplicitRecenter() {
|
||||
val pose = GlassesMenuPose(spatialEnabled = { false })
|
||||
pose.onPose(0f, 0f, 0f, 1f, time)
|
||||
pose.snapshot(time)
|
||||
pose.onPose(0f, 0f, 0.1f, 0.995f, time+1)
|
||||
val moved = pose.snapshot(time+1)
|
||||
|
||||
pose.configure(GlassesSettings(screenWidthDm = 40))
|
||||
assertArrayEquals(moved.rotation, pose.snapshot(time+2).rotation, 0f)
|
||||
assertTrue(moved.rotation.zip(HeadPose.IDENTITY.toList()).any { (a, b) -> kotlin.math.abs(a-b) > 0.1f })
|
||||
|
||||
pose.recenter()
|
||||
assertArrayEquals(HeadPose.IDENTITY, pose.snapshot(time+3).rotation, 1e-5f)
|
||||
}
|
||||
|
||||
@Test fun invalidOldAndFutureSamplesCannotReplaceTheLastSafeView() {
|
||||
val pose = GlassesMenuPose(spatialEnabled = { false })
|
||||
pose.onPose(0f, 0f, 0f, 1f, time)
|
||||
pose.snapshot(time)
|
||||
pose.onPose(0f, 0.1f, 0f, 0.995f, time+1)
|
||||
val valid = pose.snapshot(time+1)
|
||||
pose.onPose(Float.NaN, 0f, 0f, 1f, time+2)
|
||||
pose.onPose(0f, 0f, 0f, 0f, time+3)
|
||||
pose.onPose(0.1f, 0f, 0f, 0.995f, time)
|
||||
|
||||
val stale = pose.snapshot(time+GlassesMenuPose.MAX_AGE_NS+2)
|
||||
assertFalse(stale.valid)
|
||||
assertArrayEquals(valid.rotation, stale.rotation, 0f)
|
||||
pose.onPose(0.1f, 0f, 0f, 0.995f, time+1_000_000_000L)
|
||||
val future = pose.snapshot(time+20)
|
||||
assertFalse(future.valid)
|
||||
assertArrayEquals(valid.rotation, future.rotation, 0f)
|
||||
}
|
||||
|
||||
@Test fun detachResetDiscardsOldOriginAndHeldPose() {
|
||||
val pose = GlassesMenuPose(spatialEnabled = { false })
|
||||
pose.onPose(0f, 0f, 0f, 1f, time)
|
||||
pose.snapshot(time)
|
||||
pose.onPose(0f, 0.2f, 0f, 0.98f, time+1)
|
||||
pose.snapshot(time+1)
|
||||
|
||||
pose.reset()
|
||||
assertFalse(pose.snapshot(time+2).valid)
|
||||
assertArrayEquals(HeadPose.IDENTITY, pose.snapshot(time+2).rotation, 0f)
|
||||
pose.onPose(0.2f, 0f, 0f, 0.98f, time+3)
|
||||
assertArrayEquals(HeadPose.IDENTITY, pose.snapshot(time+3).rotation, 1e-5f)
|
||||
}
|
||||
|
||||
@Test fun spatialScreenPoseKeepsMetresAndHoldsDuringTrackingLoss() {
|
||||
var current: SpatialPose? = SpatialPose(SpatialVector(0.2f, -0.1f, 0.3f), SpatialRotation(y = 0.1f, w = 0.995f))
|
||||
var recenters = 0
|
||||
val pose = GlassesMenuPose({ true }, { current }, { recenters++ })
|
||||
pose.configure(GlassesSettings(positionalTracking = true))
|
||||
val valid = pose.snapshot(time)
|
||||
|
||||
assertTrue(valid.spatial)
|
||||
assertTrue(valid.valid)
|
||||
assertArrayEquals(floatArrayOf(0.2f, -0.1f, 0.3f), valid.position, 0f)
|
||||
current = null
|
||||
val lost = pose.snapshot(time+1)
|
||||
assertFalse(lost.valid)
|
||||
assertArrayEquals(valid.position, lost.position, 0f)
|
||||
assertArrayEquals(valid.rotation, lost.rotation, 0f)
|
||||
pose.recenter()
|
||||
assertEquals(1, recenters)
|
||||
}
|
||||
|
||||
@Test fun disabledTrackingReturnsAnUntranslatedCenteredView() {
|
||||
val pose = GlassesMenuPose({ true }, { SpatialPose(SpatialVector(x = 0.2f)) }, {})
|
||||
pose.configure(GlassesSettings(positionalTracking = true))
|
||||
pose.snapshot(time)
|
||||
|
||||
pose.configure(GlassesSettings(headTracking = false, positionalTracking = true))
|
||||
|
||||
val frame = pose.snapshot(time+1)
|
||||
assertFalse(frame.valid)
|
||||
assertArrayEquals(HeadPose.IDENTITY, frame.rotation, 0f)
|
||||
assertArrayEquals(FloatArray(3), frame.position, 0f)
|
||||
}
|
||||
|
||||
@Test fun menuRecenterChangesTheScreenOriginWithoutMovingTheVrFloorOrigin() {
|
||||
val session = SpatialSession()
|
||||
session.reset(1, 1.6f)
|
||||
session.accept(SpatialSample(SpatialPose(SpatialVector(1f, 2f, 3f)), time, 1, true))
|
||||
session.accept(SpatialSample(SpatialPose(SpatialVector(1.2f, 2.1f, 3f)), time+1, 1, true))
|
||||
val pose = GlassesMenuPose({ true }, { now -> session.view(true).takeIf { session.valid(now) } },
|
||||
{ session.recenter(true, time+1) })
|
||||
pose.configure(GlassesSettings(positionalTracking = true))
|
||||
val vrBefore = session.view(false)!!
|
||||
assertArrayEquals(floatArrayOf(0.2f, 0.1f, 0f), pose.snapshot(time+1).position, 1e-5f)
|
||||
|
||||
pose.recenter()
|
||||
|
||||
assertArrayEquals(FloatArray(3), pose.snapshot(time+1).position, 1e-5f)
|
||||
assertEquals(vrBefore, session.view(false))
|
||||
}
|
||||
|
||||
@Test fun malformedSpatialPoseCannotReplaceTheHeldView() {
|
||||
var current = SpatialPose(SpatialVector(x = 0.1f))
|
||||
val pose = GlassesMenuPose({ true }, { current }, {})
|
||||
pose.configure(GlassesSettings(positionalTracking = true))
|
||||
val valid = pose.snapshot(time)
|
||||
|
||||
current = SpatialPose(SpatialVector(x = Float.NaN))
|
||||
assertFalse(pose.snapshot(time+1).valid)
|
||||
assertArrayEquals(valid.position, pose.snapshot(time+1).position, 0f)
|
||||
current = SpatialPose(rotation = SpatialRotation(w = 0f))
|
||||
assertFalse(pose.snapshot(time+2).valid)
|
||||
assertArrayEquals(valid.rotation, pose.snapshot(time+2).rotation, 0f)
|
||||
}
|
||||
|
||||
@Test fun snapshotsDoNotExposeTheHeldArraysForMutation() {
|
||||
val pose = GlassesMenuPose(spatialEnabled = { false })
|
||||
pose.onPose(0f, 0f, 0f, 1f, time)
|
||||
pose.snapshot(time).rotation.fill(Float.NaN)
|
||||
|
||||
assertArrayEquals(HeadPose.IDENTITY, pose.snapshot(time+GlassesMenuPose.MAX_AGE_NS+1).rotation, 1e-5f)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import com.droiddeck.launcher.gpu.HeadPose
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertNotNull
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Test
|
||||
|
||||
class GlassesMenuProjectionTest {
|
||||
private fun frame(rotation: FloatArray = HeadPose.IDENTITY, position: FloatArray = FloatArray(3)) =
|
||||
GlassesMenuPose.Frame(rotation, position, true, false)
|
||||
|
||||
private fun hit(pose: GlassesMenuPose.Frame = frame(), x: Float = 0f, y: Float = 0f, eye: Float = 0f,
|
||||
aspect: Float = 2f) = GlassesMenuProjection.intersect(pose, x, y, eye, 1f, 3f, aspect)
|
||||
|
||||
@Test fun centeredForwardRaySamplesTheTextureCenter() {
|
||||
assertEquals(GlassesMenuProjection.Uv(0.5f, 0.5f), hit())
|
||||
}
|
||||
|
||||
@Test fun screenTopAndRightRaysUseTopLeftTextureCoordinates() {
|
||||
val topRight = hit(x = 1f/3f, y = -1f/6f)!!
|
||||
assertEquals(1f, topRight.x, 1e-5f)
|
||||
assertEquals(0f, topRight.y, 1e-5f)
|
||||
}
|
||||
|
||||
@Test fun eyeOriginsShiftByPhysicalIpdWhileMonoUsesTheCenter() {
|
||||
val left = hit(eye = -GlassesMenuSurface.IPD_METERS/2)!!
|
||||
val right = hit(eye = GlassesMenuSurface.IPD_METERS/2)!!
|
||||
assertEquals(0.484f, left.x, 1e-5f)
|
||||
assertEquals(0.516f, right.x, 1e-5f)
|
||||
assertEquals(0.5f, hit()!!.x, 0f)
|
||||
}
|
||||
|
||||
@Test fun translatedHeadUsesMetresInTheAnchoredScreenFrame() {
|
||||
val translated = hit(frame(position = floatArrayOf(0.2f, 0.1f, 0f)))!!
|
||||
assertEquals(0.6f, translated.x, 1e-5f)
|
||||
assertEquals(0.4f, translated.y, 1e-5f)
|
||||
}
|
||||
|
||||
@Test fun rowMajorPositiveYawTurnsTheForwardRayTowardNegativeX() {
|
||||
val angle = Math.toRadians(10.0)
|
||||
val rotation = SpatialRotation(y = kotlin.math.sin(angle/2).toFloat(), w = kotlin.math.cos(angle/2).toFloat()).matrix()
|
||||
assertEquals(0.5f - 1.5f*kotlin.math.tan(angle).toFloat(), hit(frame(rotation))!!.x, 1e-5f)
|
||||
}
|
||||
|
||||
@Test fun aRayBehindTheHeadOrOutsideThePlaneHasNoUiHit() {
|
||||
assertNull(hit(frame(rotation = SpatialRotation(y = 1f, w = 0f).matrix())))
|
||||
assertNull(hit(x = 1f))
|
||||
assertNull(hit(frame(position = floatArrayOf(0f, 0f, -4f))))
|
||||
}
|
||||
|
||||
@Test fun sourceAspectChangesThePlaneHeightWithoutStretchingItsWidth() {
|
||||
assertNotNull(hit(y = 0.2f, aspect = 1f))
|
||||
assertNull(hit(y = 0.2f, aspect = 2f))
|
||||
}
|
||||
|
||||
@Test fun nonFiniteInputsCannotCreateTextureCoordinates() {
|
||||
assertNull(hit(x = Float.NaN))
|
||||
assertNull(hit(frame(position = floatArrayOf(Float.POSITIVE_INFINITY, 0f, 0f))))
|
||||
}
|
||||
}
|
||||
|
||||
private object GlassesMenuProjection {
|
||||
data class Uv(val x: Float, val y: Float)
|
||||
|
||||
// Row-major head-to-anchor rotation; +Y is up, -Z is forward, output UV starts at the top left.
|
||||
fun intersect(frame: GlassesMenuPose.Frame, rayX: Float, rayY: Float, eye: Float,
|
||||
halfWidth: Float, distance: Float, aspect: Float): Uv? {
|
||||
if (frame.rotation.size != 9 || frame.position.size != 3 || frame.rotation.any { !it.isFinite() } ||
|
||||
frame.position.any { !it.isFinite() } || listOf(rayX, rayY, eye, halfWidth, distance, aspect).any { !it.isFinite() } ||
|
||||
halfWidth <= 0f || distance <= 0f || aspect <= 0f) return null
|
||||
val r = frame.rotation
|
||||
val d = FloatArray(3) { row -> r[row*3]*rayX - r[row*3+1]*rayY - r[row*3+2] }
|
||||
val o = FloatArray(3) { row -> frame.position[row] + r[row*3]*eye }
|
||||
if (d[2] >= -0.0001f) return null
|
||||
val t = (-distance-o[2]) / d[2]
|
||||
if (t <= 0f) return null
|
||||
val u = (o[0]+d[0]*t) / halfWidth * 0.5f + 0.5f
|
||||
val v = -(o[1]+d[1]*t) * aspect / halfWidth * 0.5f + 0.5f
|
||||
return Uv(u, v).takeIf { u in 0f..1f && v in 0f..1f }
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,25 @@ class GlassesRenderingTest {
|
||||
)
|
||||
private val base = Cardboard(ipdMm = 67)
|
||||
|
||||
@Test fun thirtyHzRequiresANativeModeAndDedicatedGlassesOutput() {
|
||||
val settings = GlassesSettings(refreshHz = 30, sbsHz = 30)
|
||||
for (stereo in listOf(false, true)) for (sbs90 in listOf(false, true)) {
|
||||
val state = ultra.copy(sbs = stereo, sbs90 = sbs90, supports30Hz = true)
|
||||
assertTrue(GlassesRendering.refreshRates(settings, state).contains(30))
|
||||
assertEquals(30, GlassesRendering.outputHz(settings, state))
|
||||
assertEquals(60, GlassesRendering.mirrorRefreshLimit(settings, state.copy(hz = 60f), false))
|
||||
assertEquals(30, GlassesRendering.mirrorRefreshLimit(settings, state.copy(hz = 29.97f), false))
|
||||
for (unavailable in listOf(state.copy(supports30Hz = false), state.copy(noSignal = true), state.copy(displayId = -1))) {
|
||||
assertFalse(GlassesRendering.refreshRates(settings, unavailable).contains(30))
|
||||
assertEquals(60, GlassesRendering.outputHz(settings, unavailable))
|
||||
}
|
||||
val mirrored = settings.copy(gameOnGlasses = false)
|
||||
assertFalse(GlassesRendering.refreshRates(mirrored, state).contains(30))
|
||||
assertEquals(60, GlassesRendering.outputHz(mirrored, state))
|
||||
assertEquals(60, GlassesRendering.mirrorRefreshLimit(mirrored, state, false))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun mirroredRefreshUsesTheSelectedGlassesRateEvenBeforeTheDisplaySwitches() {
|
||||
val settings = GlassesSettings(gameOnGlasses = false, refreshHz = 60)
|
||||
assertEquals(60, GlassesRendering.mirrorRefreshLimit(settings, ultra.copy(hz = 120f), false))
|
||||
@@ -75,27 +94,82 @@ class GlassesRenderingTest {
|
||||
assertFalse(changed.headTracking)
|
||||
}
|
||||
|
||||
@Test fun automatic3dGamesUseAVirtualScreenButSteamVrUsesDirectStereo() {
|
||||
@Test fun automaticSbsDuplicatesTheWholeFrameWithoutEnablingHeadTracking() {
|
||||
val settings = GlassesSettings()
|
||||
val stereo = ultra.copy(sbs = true, width = 3840)
|
||||
assertEquals(GlassesRendering.Picture.VIRTUAL_SCREEN, GlassesRendering.picture(settings, true, false))
|
||||
assertEquals(Cardboard.SOURCE_SCREEN, render(settings, stereo).source)
|
||||
assertEquals(GlassesRendering.Picture.DUPLICATED, GlassesRendering.picture(settings, true, false))
|
||||
assertEquals(Cardboard.SOURCE_FLAT, render(settings, stereo).source)
|
||||
assertFalse(render(settings, stereo).headTracking)
|
||||
assertFalse(render(settings, stereo).mono)
|
||||
assertEquals(GlassesRendering.Picture.STEREO, GlassesRendering.picture(settings, true, true))
|
||||
assertEquals(Cardboard.SOURCE_SBS, render(settings, stereo, steamVr = true).source)
|
||||
assertTrue(render(settings, stereo, steamVr = true).headTracking)
|
||||
}
|
||||
|
||||
@Test fun explicitPictureChoiceOverridesAutomaticResolution() {
|
||||
@Test fun flatSbsDoesNotDependOnTheTrackingPreferenceOrUsbControl() {
|
||||
for (tracking in listOf(false, true)) for (connected in listOf(false, true)) {
|
||||
for (height in listOf(1080, 1200)) {
|
||||
val state = ultra.copy(sbs = true, width = 3840, height = height, connected = connected)
|
||||
val settings = GlassesSettings(headTracking = tracking)
|
||||
val flat = render(settings, state)
|
||||
assertTrue(flat.enabled)
|
||||
assertFalse(flat.mono)
|
||||
assertFalse(flat.headTracking)
|
||||
assertEquals(Cardboard.SOURCE_FLAT, flat.source)
|
||||
assertEquals(Cardboard.SOURCE_SBS, render(settings.copy(picture3d = GlassesSettings.PICTURE_SBS), state).source)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun virtualScreenTracksFlatContentIndependentlyOfTheHardwareSbsMode() {
|
||||
val settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN)
|
||||
assertTrue(settings.screen3dof)
|
||||
assertFalse(settings.copy(headTracking = false).screen3dof)
|
||||
for (height in listOf(1080, 1200)) {
|
||||
for (sbs in listOf(false, true)) {
|
||||
val projection = render(settings, ultra.copy(width = if (sbs) 3840 else 1920, height = height, sbs = sbs))
|
||||
assertTrue(projection.enabled)
|
||||
assertTrue(projection.headTracking)
|
||||
assertEquals(Cardboard.SOURCE_SCREEN, projection.source)
|
||||
assertEquals(!sbs, projection.mono)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun explicitPictureChoiceOverridesAutomaticResolutionOutsideSteamVr() {
|
||||
val virtual = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN)
|
||||
val direct = GlassesSettings(picture3d = GlassesSettings.PICTURE_SBS)
|
||||
for (stereo in listOf(false, true)) {
|
||||
for (vr in listOf(false, true)) {
|
||||
assertEquals(GlassesRendering.Picture.VIRTUAL_SCREEN, GlassesRendering.picture(virtual, stereo, vr))
|
||||
assertEquals(GlassesRendering.Picture.STEREO, GlassesRendering.picture(direct, stereo, vr))
|
||||
assertEquals(GlassesRendering.Picture.VIRTUAL_SCREEN, GlassesRendering.picture(virtual, stereo, false))
|
||||
assertEquals(GlassesRendering.Picture.STEREO, GlassesRendering.picture(direct, stereo, false))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun steamVrSplitsTheEyePairRegardlessOfTheSavedFlatGamePicture() {
|
||||
for (picture in listOf(GlassesSettings.PICTURE_AUTO, GlassesSettings.PICTURE_SCREEN, GlassesSettings.PICTURE_SBS)) {
|
||||
val settings = GlassesSettings(picture3d = picture, auto3d = true)
|
||||
for (stereo in listOf(false, true)) for (outputActive in listOf(false, true)) {
|
||||
val state = ultra.copy(sbs = stereo, width = if (stereo) 3840 else 1920)
|
||||
val projection = GlassesRendering.cardboard(base, settings, state, outputActive, true)
|
||||
assertEquals(GlassesRendering.Picture.STEREO, GlassesRendering.picture(settings, stereo, true))
|
||||
assertEquals(Cardboard.SOURCE_SBS, projection.source)
|
||||
assertEquals(!stereo, projection.mono)
|
||||
assertTrue(projection.enabled)
|
||||
assertTrue(projection.headTracking)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun stoppingSteamVrRestoresTheSavedVirtualScreen() {
|
||||
val settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN, auto3d = true,
|
||||
screenWidthDm = 18, screenDistanceDm = 30)
|
||||
val before = render(settings)
|
||||
assertEquals(Cardboard.SOURCE_SCREEN, before.source)
|
||||
assertEquals(Cardboard.SOURCE_SBS, render(settings, steamVr = true).source)
|
||||
assertEquals(before, render(settings))
|
||||
assertEquals(GlassesSettings.PICTURE_SCREEN, settings.picture3d)
|
||||
}
|
||||
|
||||
@Test fun mirrorModeKeepsThePhoneProjectionInsteadOfApplyingDormantGlassesSettings() {
|
||||
val phone = base.copy(enabled = true, screenWidthDm = 60, screenDistanceDm = 20)
|
||||
val settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN,
|
||||
|
||||
@@ -4,6 +4,8 @@ import android.hardware.display.DisplayManager
|
||||
import android.view.Display
|
||||
import android.view.SurfaceHolder
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
@@ -21,6 +23,40 @@ import org.robolectric.shadows.ShadowDisplayManager
|
||||
@Config(sdk = [31, 34], manifest = Config.NONE, shadows = [GlassesScreenTest.ModeDisplay::class])
|
||||
@LooperMode(LooperMode.Mode.PAUSED)
|
||||
class GlassesScreenTest {
|
||||
@Test fun recoveryCoversTheExistingRenderSurfaceWithoutReplacingIt() {
|
||||
val flat=mode(1,1920,1200,60f)
|
||||
val (screen,_)=screen(flat,arrayOf(flat),60)
|
||||
val holder=screen.holder
|
||||
val root=screen.surfaceView.parent as android.view.ViewGroup
|
||||
assertTrue(root.indexOfChild(screen.trackingRecovery)>root.indexOfChild(screen.surfaceView))
|
||||
screen.trackingRecovery.update(TrackingRecovery.LOST,false)
|
||||
assertEquals(android.view.View.VISIBLE,screen.trackingRecovery.visibility)
|
||||
screen.trackingRecovery.update(null,false)
|
||||
assertEquals(android.view.View.GONE,screen.trackingRecovery.visibility)
|
||||
assertTrue(holder===screen.holder)
|
||||
}
|
||||
|
||||
@Test fun nativeThirtyHzMustMatchBothDimensionsOfTheCurrentEyeLayout() {
|
||||
val flat60 = mode(1, 1920, 1200, 60f)
|
||||
val flat30 = mode(2, 1920, 1200, 29.97f)
|
||||
val stereo60 = mode(3, 3840, 1200, 60f)
|
||||
val stereo30 = mode(4, 3840, 1200, 30f)
|
||||
val short30 = mode(5, 3840, 1080, 30f)
|
||||
val (screen, panel) = screen(flat60, arrayOf(flat60, flat30, stereo60, short30), 30)
|
||||
assertTrue(Glasses.supports30Hz(screen.display))
|
||||
assertEquals(flat30.modeId, screen.window!!.attributes.preferredDisplayModeId)
|
||||
|
||||
panel.current = stereo60
|
||||
screen.prefer(30)
|
||||
assertFalse(Glasses.supports30Hz(screen.display))
|
||||
assertEquals(stereo60.modeId, screen.window!!.attributes.preferredDisplayModeId)
|
||||
|
||||
panel.supported += stereo30
|
||||
screen.prefer(30)
|
||||
assertTrue(Glasses.supports30Hz(screen.display))
|
||||
assertEquals(stereo30.modeId, screen.window!!.attributes.preferredDisplayModeId)
|
||||
}
|
||||
|
||||
@Test fun switchingBetween2dAndStereoRefreshesTheModePreferenceEvenAtTheSameHz() {
|
||||
val flat = mode(1, 1920, 1200, 60f)
|
||||
val stereo = mode(2, 3840, 1200, 60f)
|
||||
@@ -54,6 +90,30 @@ class GlassesScreenTest {
|
||||
assertEquals(stereo90.modeId, screen.window!!.attributes.preferredDisplayModeId)
|
||||
}
|
||||
|
||||
@Test fun explicitResolutionChangesBothDimensionsWithoutSwitchingEyeLayout() {
|
||||
val flat1080 = mode(1, 1920, 1080, 90f)
|
||||
val flat1200 = mode(2, 1920, 1200, 90f)
|
||||
val stereo1080 = mode(3, 3840, 1080, 90f)
|
||||
val stereo1200 = mode(4, 3840, 1200, 90f)
|
||||
val (screen, panel) = screen(flat1200, arrayOf(flat1080, flat1200, stereo1080, stereo1200), 90)
|
||||
screen.prefer(90, GlassesResolution(1920, 1080))
|
||||
assertEquals(flat1080.modeId, screen.window!!.attributes.preferredDisplayModeId)
|
||||
panel.current = stereo1200
|
||||
screen.prefer(90, GlassesResolution(1920, 1080))
|
||||
assertEquals(stereo1080.modeId, screen.window!!.attributes.preferredDisplayModeId)
|
||||
screen.prefer(90, GlassesResolution(1920, 1200))
|
||||
assertEquals(stereo1200.modeId, screen.window!!.attributes.preferredDisplayModeId)
|
||||
}
|
||||
|
||||
@Test fun unavailableResolutionKeepsTheCurrentModeUntilHardwareConfirmsTheChange() {
|
||||
val stereo60 = mode(1, 3840, 1200, 60f)
|
||||
val stereo90 = mode(2, 3840, 1200, 90f)
|
||||
val flat1080 = mode(3, 1920, 1080, 90f)
|
||||
val (screen, _) = screen(stereo60, arrayOf(stereo60, stereo90, flat1080), 60)
|
||||
screen.prefer(90, GlassesResolution(1920, 1080))
|
||||
assertEquals(stereo90.modeId, screen.window!!.attributes.preferredDisplayModeId)
|
||||
}
|
||||
|
||||
private fun mode(id: Int, width: Int, height: Int, hz: Float): Display.Mode =
|
||||
ShadowDisplayManager.ModeBuilder.modeBuilder(id)
|
||||
.setWidth(width).setHeight(height).setRefreshRate(hz).build()
|
||||
|
||||
@@ -0,0 +1,152 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import android.app.Application
|
||||
import android.content.Intent
|
||||
import android.hardware.display.DisplayManager
|
||||
import android.view.Display
|
||||
import androidx.compose.runtime.MutableState
|
||||
import com.droiddeck.launcher.SessionActivity
|
||||
import com.droiddeck.launcher.gpu.Cardboard
|
||||
import com.droiddeck.launcher.gpu.SteamVr
|
||||
import com.droiddeck.launcher.runtime.FlatpakManager
|
||||
import com.droiddeck.launcher.session.LoadingState
|
||||
import com.droiddeck.launcher.session.SessionService
|
||||
import com.droiddeck.launcher.session.SessionState
|
||||
import org.junit.After
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.Robolectric
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.RuntimeEnvironment
|
||||
import org.robolectric.annotation.Config
|
||||
import org.robolectric.annotation.LooperMode
|
||||
import org.robolectric.shadows.ShadowDisplayManager
|
||||
import org.robolectric.util.ReflectionHelpers
|
||||
import org.robolectric.util.ReflectionHelpers.ClassParameter
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [28], application = Application::class, manifest = Config.NONE)
|
||||
@LooperMode(LooperMode.Mode.PAUSED)
|
||||
class GlassesSessionModesTest {
|
||||
private data class Launch(val name: String, val mode: String, val program: String? = null, val args: Array<String>? = null)
|
||||
private val launches = listOf(
|
||||
Launch("Steam and store games", SessionService.MODE_STEAM),
|
||||
Launch("Desktop", SessionService.MODE_DESKTOP),
|
||||
Launch("Standalone", SessionService.MODE_RUN, "/usr/bin/example-game"),
|
||||
Launch("Emulator", SessionService.MODE_RUN, "/usr/bin/retroarch", arrayOf("/games/example.rom")),
|
||||
Launch("Flatpak", SessionService.MODE_RUN, FlatpakManager.LAUNCHER, arrayOf("org.example.Game")),
|
||||
)
|
||||
private lateinit var display: Display
|
||||
private lateinit var restore: () -> Unit
|
||||
private val saved = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN,
|
||||
headTracking = true, screenWidthDm = 35, screenDistanceDm = 45)
|
||||
private val phone = Cardboard(enabled = true, source = Cardboard.SOURCE_SCREEN, ipdMm = 67,
|
||||
screenWidthDm = 20, screenDistanceDm = 30, headTracking = false)
|
||||
|
||||
@Before fun setUp() {
|
||||
val running = SessionState.running
|
||||
val steamVr = SessionState.steamVr
|
||||
val mode = SessionState.mode
|
||||
val fields = listOf("context", "publisherAttached").associateWith {
|
||||
SpatialTracking::class.java.getDeclaredField(it).apply { isAccessible = true }
|
||||
}
|
||||
val values = fields.mapValues { it.value.get(null) }
|
||||
fields.getValue("context").set(null, null)
|
||||
fields.getValue("publisherAttached").set(null, false)
|
||||
restore = {
|
||||
fields.forEach { (name, field) -> field.set(null, values[name]) }
|
||||
SessionState.running = running
|
||||
SessionState.steamVr = steamVr
|
||||
SessionState.mode = mode
|
||||
}
|
||||
val id = ShadowDisplayManager.addDisplay("w1920dp-h1080dp")
|
||||
display = RuntimeEnvironment.getApplication().getSystemService(DisplayManager::class.java).getDisplay(id)
|
||||
SessionState.running = true
|
||||
SessionState.steamVr = false
|
||||
}
|
||||
|
||||
@After fun tearDown() {
|
||||
SpatialTracking.useLegacyTracking()
|
||||
SpatialTracking.disconnect()
|
||||
ShadowDisplayManager.removeDisplay(display.displayId)
|
||||
restore()
|
||||
}
|
||||
|
||||
@Test fun flatScreenSizeDistanceAndTrackingReachEveryGuestSessionWithoutSteamVr() {
|
||||
for (launch in launches) for (spatial in listOf(false, true)) {
|
||||
val activity = activity(launch, saved.copy(positionalTracking = spatial), output = true)
|
||||
SpatialTracking.connect(0, 101, null, spatial, 1.6f, false)
|
||||
val projection = projection(activity)
|
||||
|
||||
assertTrue(launch.name, projection.enabled)
|
||||
assertTrue(launch.name, projection.headTracking)
|
||||
assertTrue(launch.name, projection.mono)
|
||||
assertEquals(launch.name, Cardboard.SOURCE_SCREEN, projection.source)
|
||||
assertEquals(launch.name, Cardboard.Viewer.VITURE.id, projection.viewer)
|
||||
assertEquals(launch.name, 35, projection.screenWidthDm)
|
||||
assertEquals(launch.name, 45, projection.screenDistanceDm)
|
||||
assertEquals(launch.name, phone.ipdMm, projection.ipdMm)
|
||||
assertEquals(launch.name, if (spatial) TrackingRecovery.LOST else null, recovery(activity))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun positionalRecoverySurvivesUsbLossInEveryGuestSessionAndHonorsTrackingOff() {
|
||||
for (launch in launches) {
|
||||
val activity = activity(launch, saved.copy(positionalTracking = true), output = true)
|
||||
SpatialTracking.connect(0, 102, null, true, 1.6f, false)
|
||||
assertEquals(launch.name, TrackingRecovery.LOST, recovery(activity))
|
||||
|
||||
SpatialTracking.disconnect()
|
||||
state(activity, "glasses", glasses().copy(connected = false, supportsSpatial = false))
|
||||
assertEquals(launch.name, TrackingRecovery.DISCONNECTED, recovery(activity))
|
||||
|
||||
state(activity, "glassesSettings", saved.copy(positionalTracking = true, headTracking = false))
|
||||
assertFalse(launch.name, projection(activity).headTracking)
|
||||
assertNull(launch.name, recovery(activity))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun savedGlassesTrackingDoesNotChangePhoneRenderingOrRecoveryInAnySessionMode() {
|
||||
for (launch in launches) {
|
||||
val activity = activity(launch, saved.copy(positionalTracking = true), output = false)
|
||||
SpatialTracking.connect(0, 103, null, true, 1.6f, false)
|
||||
|
||||
assertSame(launch.name, phone, projection(activity))
|
||||
assertNull(launch.name, recovery(activity))
|
||||
}
|
||||
}
|
||||
|
||||
private fun activity(launch: Launch, settings: GlassesSettings, output: Boolean): SessionActivity {
|
||||
val intent = Intent(RuntimeEnvironment.getApplication(), SessionActivity::class.java)
|
||||
.putExtra(SessionService.EXTRA_MODE, launch.mode)
|
||||
.putExtra(SessionService.EXTRA_PROGRAM, launch.program)
|
||||
.putExtra(SessionService.EXTRA_PROGRAM_ARGS, launch.args)
|
||||
SessionState.mode = launch.mode
|
||||
return Robolectric.buildActivity(SessionActivity::class.java, intent).get().also {
|
||||
ReflectionHelpers.setField(it, "loading", LoadingState(it).apply { visible = false })
|
||||
ReflectionHelpers.setField(it, "started", true)
|
||||
if (output) ReflectionHelpers.setField(it, "glassesScreen", GlassesScreen(it, display, 60, it))
|
||||
state(it, "glassesOutputActive", output)
|
||||
state(it, "glasses", glasses())
|
||||
state(it, "glassesSettings", settings)
|
||||
state(it, "steamVrStatus", SteamVr.Status.READY)
|
||||
}
|
||||
}
|
||||
|
||||
private fun glasses() = GlassesState(present = true, connected = true, controllable = true,
|
||||
supportsSpatial = true, supportsScreen3dof = true, displayId = display.displayId, width = 1920, height = 1080)
|
||||
|
||||
private fun projection(activity: SessionActivity): Cardboard = ReflectionHelpers.callInstanceMethod(
|
||||
activity, "effectiveCardboard", ClassParameter.from(Cardboard::class.java, phone))
|
||||
|
||||
private fun recovery(activity: SessionActivity): TrackingRecovery? {
|
||||
ReflectionHelpers.callInstanceMethod<Void>(activity, "updateTrackingRecovery")
|
||||
return ReflectionHelpers.getField<MutableState<TrackingRecovery?>>(activity, "trackingRecovery\$delegate").value
|
||||
}
|
||||
|
||||
private fun <T> state(activity: SessionActivity, name: String, value: T) {
|
||||
ReflectionHelpers.getField<MutableState<T>>(activity, name + "\$delegate").value = value
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
|
||||
class GlassesSpatialAvailabilityTest {
|
||||
private val ultra = GlassesState(connected = true, controllable = true, supportsSpatial = true)
|
||||
private val selected = GlassesSettings(positionalTracking = true, handControllers = true)
|
||||
|
||||
@Test fun sdkConfirmedConnectedUltraOwnsSpatialControllerInput() {
|
||||
assertTrue(ultra.spatialConnected)
|
||||
assertTrue(ultra.usesSpatialControllers(selected))
|
||||
assertTrue(ultra.usesSpatialControllers(selected.copy(handControllers = false, joyConTracking = true)))
|
||||
assertFalse(ultra.usesSpatialControllers(selected.copy(positionalTracking = false)))
|
||||
assertFalse(ultra.usesSpatialControllers(selected.copy(handControllers = false)))
|
||||
}
|
||||
|
||||
@Test fun savedUltraPreferencesDoNotSelectSpatialInputForOtherGlasses() {
|
||||
for (name in listOf("VITURE Luma Ultra", "VITURE Luma Pro", "VITURE Pro", "XREAL", "RayNeo")) {
|
||||
val other = ultra.copy(model = name, supportsSpatial = false)
|
||||
assertFalse(name, other.spatialConnected)
|
||||
assertFalse(name, other.usesSpatialControllers(selected))
|
||||
assertFalse(name, other.usesSpatialControllers(selected.copy(handControllers = false, joyConTracking = true)))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun disconnectedOrUncontrollableUltraCannotClaimSpatialInput() {
|
||||
for (state in listOf(ultra.copy(connected = false), ultra.copy(controllable = false), GlassesState())) {
|
||||
assertFalse(state.spatialConnected)
|
||||
assertFalse(state.usesSpatialControllers(selected))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4,6 +4,7 @@ import android.app.Application
|
||||
import android.content.Context
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import android.os.SystemClock
|
||||
import com.droiddeck.launcher.SessionActivity
|
||||
import com.droiddeck.launcher.gpu.SteamVr
|
||||
import com.droiddeck.launcher.session.LoadingState
|
||||
@@ -24,6 +25,7 @@ import org.robolectric.annotation.LooperMode
|
||||
import java.util.concurrent.CountDownLatch
|
||||
import java.util.concurrent.ThreadPoolExecutor
|
||||
import java.util.concurrent.TimeUnit
|
||||
import java.time.Duration
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [28], application = Application::class)
|
||||
@@ -33,8 +35,10 @@ class GlassesSteamVrTest {
|
||||
private val handler = Handler(Looper.getMainLooper())
|
||||
private lateinit var restore: () -> Unit
|
||||
private fun field(name: String) = Glasses::class.java.getDeclaredField(name).apply { isAccessible = true }
|
||||
private val spatialGate get() = field("steamVrSpatialGate").get(null) as SteamVrSpatialGate
|
||||
|
||||
@Before fun prepare() {
|
||||
spatialGate.cancel()
|
||||
val fields = listOf("handler", "app", "model").associateWith { field(it).get(null) }
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val flows = listOf("_state", "_settings").map { field(it).get(null) as MutableStateFlow<Any> }
|
||||
@@ -64,6 +68,7 @@ class GlassesSteamVrTest {
|
||||
|
||||
@After fun cleanUp() {
|
||||
handler.removeCallbacksAndMessages(null)
|
||||
spatialGate.cancel()
|
||||
field("link").set(null, null)
|
||||
(field("modeState").get(null) as GlassesModeState).apply { manual(); sent(false, 0) }
|
||||
SessionState.steamVr = false
|
||||
@@ -133,6 +138,7 @@ class GlassesSteamVrTest {
|
||||
.apply { isAccessible = true }.invoke(activity, name)
|
||||
action("start")
|
||||
assertTrue("A manual start must keep status polling alive", SessionState.steamVr)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
val worker = SessionActivity::class.java.getDeclaredField("steamVrWorker")
|
||||
.apply { isAccessible = true }.get(null) as ThreadPoolExecutor
|
||||
assertEquals(1, worker.queue.size)
|
||||
@@ -146,6 +152,90 @@ class GlassesSteamVrTest {
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun preparationCallbackRunsAfterSuspensionAndCancelWorksBeforeRunning() {
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val settings = field("_settings").get(null) as MutableStateFlow<GlassesSettings>
|
||||
settings.value = GlassesSettings(positionalTracking = true, handControllers = true)
|
||||
val saved = settings.value
|
||||
var prepared = 0
|
||||
repeat(2) {
|
||||
Glasses.prepareSteamVrStart {
|
||||
assertFalse(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis()))
|
||||
prepared++
|
||||
}
|
||||
}
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertEquals(2, prepared)
|
||||
Glasses.setVrActive(false)
|
||||
shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(3))
|
||||
assertFalse(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis()))
|
||||
Glasses.cancelSteamVrStart()
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis()))
|
||||
assertEquals(saved, settings.value)
|
||||
}
|
||||
|
||||
@Test fun rapidRestartDoesNotLaunchTheCancelledPreparedRequest() = withLaunch(auto3d = false) { activity ->
|
||||
SessionState.steamVr = false
|
||||
val action = SessionActivity::class.java.getDeclaredMethod("steamVrAction", String::class.java)
|
||||
.apply { isAccessible = true }
|
||||
action.invoke(activity, "start")
|
||||
action.invoke(activity, "stop")
|
||||
action.invoke(activity, "start")
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
val worker = SessionActivity::class.java.getDeclaredField("steamVrWorker")
|
||||
.apply { isAccessible = true }.get(null) as ThreadPoolExecutor
|
||||
assertTrue(SessionState.steamVr)
|
||||
assertEquals("Only stop and the latest start should reach the worker", 2, worker.queue.size)
|
||||
}
|
||||
|
||||
@Test fun duplicateRunningKeepsDeadlineAndStoppingCancelsThePendingResume() {
|
||||
Glasses.prepareSteamVrStart()
|
||||
Glasses.setVrActive(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
val deadline = spatialGate.deadline!!
|
||||
shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(1_999))
|
||||
var prepared = false
|
||||
Glasses.prepareSteamVrStart { prepared = true }
|
||||
Glasses.setVrActive(true)
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(prepared)
|
||||
assertEquals(deadline, spatialGate.deadline)
|
||||
assertFalse(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis()))
|
||||
shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(1))
|
||||
assertTrue(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis()))
|
||||
Glasses.setVrActive(false)
|
||||
Glasses.prepareSteamVrStart()
|
||||
shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(3))
|
||||
assertFalse(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis()))
|
||||
assertNull(spatialGate.deadline)
|
||||
}
|
||||
|
||||
@Test fun restartWhileDisplayStillReportsRunningGetsANewTrackingDeadline() {
|
||||
Glasses.setVrActive(true)
|
||||
shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(3))
|
||||
assertTrue(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis()))
|
||||
Glasses.cancelSteamVrStart()
|
||||
Glasses.prepareSteamVrStart()
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
assertTrue(Glasses.state.value.vrActive)
|
||||
assertFalse(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis()))
|
||||
Glasses.setVrActive(true)
|
||||
shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(1_999))
|
||||
assertFalse(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis()))
|
||||
shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(1))
|
||||
assertTrue(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis()))
|
||||
}
|
||||
|
||||
@Test fun endedSessionIgnoresLateRunningStatus() = withLaunch(auto3d = true) { activity ->
|
||||
SessionActivity::class.java.getDeclaredField("ended").apply { isAccessible = true }.set(activity, true)
|
||||
status(activity, SteamVr.Status.RUNNING)
|
||||
assertFalse(Glasses.state.value.vrActive)
|
||||
assertNull(spatialGate.deadline)
|
||||
assertTrue(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis()))
|
||||
assertTrue(commands.isEmpty())
|
||||
}
|
||||
|
||||
private fun status(activity: SessionActivity, status: SteamVr.Status) {
|
||||
SessionActivity::class.java.getDeclaredMethod("onSteamVrStatus", SteamVr.Status::class.java)
|
||||
.apply { isAccessible = true }.invoke(activity, status)
|
||||
|
||||
@@ -0,0 +1,192 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import android.app.Application
|
||||
import android.os.HandlerThread
|
||||
import android.view.Display
|
||||
import androidx.compose.runtime.MutableState
|
||||
import com.droiddeck.launcher.SessionActivity
|
||||
import com.droiddeck.launcher.gpu.Cardboard
|
||||
import com.droiddeck.launcher.gpu.SteamVr
|
||||
import com.droiddeck.launcher.input.ControllerPrefs
|
||||
import com.droiddeck.launcher.input.JoyConVr
|
||||
import com.droiddeck.launcher.session.LoadingState
|
||||
import com.droiddeck.launcher.session.SessionState
|
||||
import java.io.File
|
||||
import java.nio.ByteBuffer
|
||||
import java.nio.ByteOrder
|
||||
import org.junit.After
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.Robolectric
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.Shadows.shadowOf
|
||||
import org.robolectric.annotation.Config
|
||||
import org.robolectric.annotation.LooperMode
|
||||
import org.robolectric.util.ReflectionHelpers
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [28], application = Application::class, manifest = Config.NONE)
|
||||
@LooperMode(LooperMode.Mode.PAUSED)
|
||||
class GlassesTrackingRoutingTest {
|
||||
private lateinit var activity: SessionActivity
|
||||
private lateinit var restore: () -> Unit
|
||||
private val ultra = GlassesState(present = true, connected = true, controllable = true,
|
||||
supportsSpatial = true, displayId = Display.DEFAULT_DISPLAY + 1, width = 1920, height = 1080)
|
||||
private val saved = GlassesSettings(positionalTracking = true, handControllers = true)
|
||||
|
||||
@Before fun setUp() {
|
||||
val running = SessionState.running
|
||||
val steamVr = SessionState.steamVr
|
||||
val fields = listOf("context", "publisherAttached").associateWith {
|
||||
SpatialTracking::class.java.getDeclaredField(it).apply { isAccessible = true }
|
||||
}
|
||||
val values = fields.mapValues { it.value.get(null) }
|
||||
fields.getValue("context").set(null, null)
|
||||
fields.getValue("publisherAttached").set(null, false)
|
||||
restore = {
|
||||
fields.forEach { (name, field) -> field.set(null, values[name]) }
|
||||
SessionState.running = running
|
||||
SessionState.steamVr = steamVr
|
||||
}
|
||||
activity = Robolectric.buildActivity(SessionActivity::class.java).get()
|
||||
ReflectionHelpers.setField(activity, "loading", LoadingState(activity).apply { visible = false })
|
||||
ReflectionHelpers.setField(activity, "started", true)
|
||||
ReflectionHelpers.setField(activity, "activeCardboard", Cardboard.OFF)
|
||||
state("glasses", ultra)
|
||||
state("glassesSettings", saved)
|
||||
state("steamVrStatus", SteamVr.Status.RUNNING)
|
||||
SessionState.running = true
|
||||
SessionState.steamVr = true
|
||||
SpatialTracking.setOutputUsesGlasses(true)
|
||||
SpatialTracking.connect(0, 81, null, true, 1.6f, true)
|
||||
}
|
||||
|
||||
@After fun tearDown() {
|
||||
SpatialTracking.useLegacyTracking()
|
||||
SpatialTracking.disconnect()
|
||||
SpatialTracking.setOutputUsesGlasses(true)
|
||||
restore()
|
||||
}
|
||||
|
||||
@Test fun usbLossKeepsSpatialOwnershipAndShowsRecoveryOnTheGlassesDisplay() {
|
||||
SpatialTracking.disconnect()
|
||||
state("glasses", ultra.copy(connected = false, supportsSpatial = false))
|
||||
updateRouting()
|
||||
|
||||
assertEquals(3, modes())
|
||||
assertTrue(SpatialTracking.selected)
|
||||
assertEquals(TrackingRecovery.DISCONNECTED, recovery())
|
||||
}
|
||||
|
||||
@Test fun phoneHandoffClearsPublishedModesWithoutErasingTheGlassesSelection() {
|
||||
for (joyCons in listOf(false, true)) {
|
||||
val selected = saved.copy(handControllers = !joyCons, joyConTracking = joyCons)
|
||||
state("glassesSettings", selected)
|
||||
SpatialTracking.connect(0, if (joyCons) 83 else 82, null, true, 1.6f, !joyCons, joyCons)
|
||||
SpatialTracking.disconnect()
|
||||
state("glasses", GlassesState())
|
||||
updateRouting()
|
||||
|
||||
assertEquals(0, modes())
|
||||
assertTrue(SpatialTracking.selected)
|
||||
assertEquals(selected, stateValue<GlassesSettings>("glassesSettings"))
|
||||
assertNull(recovery())
|
||||
SpatialTracking.setControllers(!joyCons, joyCons)
|
||||
assertEquals("Later controller updates must not reclaim the phone output", 0, modes())
|
||||
|
||||
SpatialTracking.connect(0, if (joyCons) 85 else 84, null, true, 1.6f, !joyCons, joyCons)
|
||||
assertEquals("Reconnecting waits for the output handoff", 0, modes())
|
||||
state("glasses", ultra)
|
||||
updateRouting()
|
||||
assertEquals(if (joyCons) 5 else 3, modes())
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun endingTheSessionReleasesSpatialInputEvenWhileTheGlassesRemainConnected() {
|
||||
ReflectionHelpers.setField(activity, "ended", true)
|
||||
updateRouting()
|
||||
|
||||
assertEquals(0, modes())
|
||||
assertTrue(SpatialTracking.selected)
|
||||
assertEquals(saved, stateValue<GlassesSettings>("glassesSettings"))
|
||||
assertNull(recovery())
|
||||
}
|
||||
|
||||
@Test @Config(sdk = [31]) fun displayLossReleasesSpatialControllerOverridesWhileUsbRemainsConnected() {
|
||||
val previousJoyConVr = ControllerPrefs.joyConVr(activity)
|
||||
ControllerPrefs.setJoyConVr(activity, false)
|
||||
val joyCon = JoyConVr(activity, File(activity.cacheDir, "routing-joycons")) { _, _ -> }
|
||||
ReflectionHelpers.setField(activity, "joyConVr", joyCon)
|
||||
val worker = ReflectionHelpers.getField<HandlerThread>(joyCon, "thread")
|
||||
fun updateInputs(): Boolean {
|
||||
ReflectionHelpers.callInstanceMethod<Void>(activity, "updateJoyConTracking")
|
||||
shadowOf(worker.looper).idle()
|
||||
return ReflectionHelpers.getField(joyCon, "wanted")
|
||||
}
|
||||
try {
|
||||
for (joyCons in listOf(false, true)) {
|
||||
val selected = saved.copy(handControllers = !joyCons, joyConTracking = joyCons)
|
||||
state("glassesSettings", selected)
|
||||
for (displayLost in listOf(ultra.copy(noSignal = true), ultra.copy(displayId = Display.INVALID_DISPLAY))) {
|
||||
state("glasses", ultra)
|
||||
assertTrue(ReflectionHelpers.callInstanceMethod(activity, "usesSpatialControllers"))
|
||||
assertEquals(joyCons, updateInputs())
|
||||
|
||||
state("glasses", displayLost)
|
||||
updateRouting()
|
||||
assertTrue(displayLost.spatialConnected)
|
||||
assertEquals(0, modes())
|
||||
assertFalse("The phone camera must not be suppressed by a missing display",
|
||||
ReflectionHelpers.callInstanceMethod(activity, "usesSpatialControllers"))
|
||||
assertFalse("Saved glasses Joy-Cons must not override the phone preference", updateInputs())
|
||||
assertEquals(selected, stateValue<GlassesSettings>("glassesSettings"))
|
||||
ControllerPrefs.setJoyConVr(activity, true)
|
||||
assertTrue("The phone Joy-Con preference must still apply", updateInputs())
|
||||
ControllerPrefs.setJoyConVr(activity, false)
|
||||
|
||||
state("glasses", ultra)
|
||||
updateRouting()
|
||||
assertTrue(ReflectionHelpers.callInstanceMethod(activity, "usesSpatialControllers"))
|
||||
assertEquals(joyCons, updateInputs())
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
ReflectionHelpers.setField(activity, "joyConVr", null)
|
||||
joyCon.close()
|
||||
ControllerPrefs.setJoyConVr(activity, previousJoyConVr)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun anotherGlassesModelDoesNotActivateSavedUltraTracking() {
|
||||
SpatialTracking.disconnect()
|
||||
SpatialTracking.useLegacyTracking()
|
||||
state("glasses", ultra.copy(model = "XREAL", supportsSpatial = false))
|
||||
updateRouting()
|
||||
|
||||
assertEquals(0, modes())
|
||||
assertFalse(SpatialTracking.selected)
|
||||
assertEquals(saved, stateValue<GlassesSettings>("glassesSettings"))
|
||||
assertNull(recovery())
|
||||
}
|
||||
|
||||
private fun updateRouting() {
|
||||
ReflectionHelpers.callInstanceMethod<Void>(activity, "updateHeadTracker")
|
||||
ReflectionHelpers.callInstanceMethod<Void>(activity, "updateTrackingRecovery")
|
||||
}
|
||||
|
||||
private fun modes(): Int {
|
||||
val field = SpatialTracking::class.java.getDeclaredField("buffer").apply { isAccessible = true }
|
||||
return (field.get(null) as ByteBuffer).duplicate().order(ByteOrder.LITTLE_ENDIAN).getInt(32)
|
||||
}
|
||||
|
||||
private fun recovery(): TrackingRecovery? = stateValue("trackingRecovery")
|
||||
|
||||
private fun <T> state(name: String, value: T) {
|
||||
ReflectionHelpers.getField<MutableState<T>>(activity, name + "\$delegate").value = value
|
||||
}
|
||||
|
||||
private fun <T> stateValue(name: String): T =
|
||||
ReflectionHelpers.getField<MutableState<T>>(activity, name + "\$delegate").value
|
||||
}
|
||||
@@ -165,6 +165,36 @@ class GlassesUsbTest {
|
||||
assertEquals(listOf(gt), manager.requests)
|
||||
}
|
||||
|
||||
@Test fun screen3dofAvailabilityFollowsTheTrackingTransportAcrossBrands() {
|
||||
val devices = listOf(device(0x1011), device(0x1019), device(0x1131),
|
||||
device(0xaf50, 0x1bbb, "RayNeo Air 4 Pro"),
|
||||
device(0xaf50, 0x3941, "RayNeo GT MAX"),
|
||||
device(0x043e, 0x3318, "XREAL 1S"))
|
||||
try {
|
||||
for (device in devices) for (imu in listOf(false, true)) {
|
||||
manager.devices.clear()
|
||||
manager.devices[device.deviceName] = device
|
||||
manager.granted.add(device.deviceName)
|
||||
field("linkDevice").set(null, device)
|
||||
field("link").set(null, object : GlassesLink {
|
||||
override val hasImu = imu
|
||||
override fun send(msgId: Int, payload: ByteArray) = true
|
||||
override fun close() {}
|
||||
})
|
||||
refresh()
|
||||
assertTrue(state.value.canControl)
|
||||
assertEquals(imu, state.value.supportsScreen3dof)
|
||||
}
|
||||
manager.devices.clear()
|
||||
refresh()
|
||||
assertFalse(state.value.supportsScreen3dof)
|
||||
} finally {
|
||||
field("link").set(null, null)
|
||||
field("linkDevice").set(null, null)
|
||||
(field("handler").get(null) as Handler).removeCallbacksAndMessages(null)
|
||||
}
|
||||
}
|
||||
|
||||
private fun refresh(ask: Boolean = false) {
|
||||
Glasses::class.java.getDeclaredMethod("refresh", Boolean::class.javaPrimitiveType)
|
||||
.apply { isAccessible = true }.invoke(Glasses, ask)
|
||||
|
||||
@@ -0,0 +1,192 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
|
||||
class HandGesturesTest {
|
||||
private fun openHand(): MutableList<SpatialVector> {
|
||||
val p=MutableList(21) { SpatialVector(z=.5f) }
|
||||
p[0]=SpatialVector(0f,0f,.5f)
|
||||
p[4]=SpatialVector(.07f,-.05f,.5f)
|
||||
for((base,x) in listOf(5 to .035f,9 to .01f,13 to -.015f,17 to -.04f)) {
|
||||
for(j in 0..3)p[base+j]=SpatialVector(x,-.06f-.025f*j,.5f)
|
||||
}
|
||||
return p
|
||||
}
|
||||
@Test fun triangulatedMetersAreTransformedIntoTheHeadWorldFrame() {
|
||||
val h=HandGestures(rightHand=false).estimate(openHand(),SpatialPose(SpatialVector(1f,2f,3f)),1_000_000_000)!!
|
||||
assertEquals(3.5f,h.pose.position.z,.0001f)
|
||||
assertTrue(h.pose.rotation.normalized()!=null);assertFalse(h.grip);assertEquals(0f,h.trigger,.0001f)
|
||||
}
|
||||
@Test fun mirroredHandsUseTheSamePalmNormalAndFingerDirection() {
|
||||
val left=openHand().apply { this[9]=SpatialVector(0f,-.06f,.5f) }
|
||||
val right=left.map { SpatialVector(-it.x,it.y,it.z) }
|
||||
val world=SpatialPose(SpatialVector(1f,2f,3f),SpatialRotation(.2f,-.3f,.1f,.9f).normalized()!!)
|
||||
for(turn in listOf(SpatialRotation(),SpatialRotation(y=1f,w=0f),
|
||||
SpatialRotation(.3f,.1f,-.2f,.9f).normalized()!!)) {
|
||||
val hands=listOf(left,right).mapIndexed { side,points ->
|
||||
HandGestures(rightHand=side==1).estimate(points.map(turn::apply),world,1_000_000_000)!!
|
||||
}
|
||||
for(hand in hands) {
|
||||
val rotation=hand.pose.rotation
|
||||
assertVector(world.rotation.apply(turn.apply(SpatialVector(z=-1f))),rotation.apply(SpatialVector(y=1f)))
|
||||
assertVector(world.rotation.apply(turn.apply(SpatialVector(y=-1f))),rotation.apply(SpatialVector(z=-1f)))
|
||||
val x=rotation.apply(SpatialVector(x=1f));val y=rotation.apply(SpatialVector(y=1f))
|
||||
assertVector(rotation.apply(SpatialVector(z=1f)),x.cross(y))
|
||||
}
|
||||
}
|
||||
}
|
||||
@Test fun rightHandOrientationDoesNotChangePinchOrGrip() {
|
||||
val points=openHand()
|
||||
points[4]=points[8]
|
||||
for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) points[tip]=points[base]
|
||||
val left=HandGestures(rightHand=false).estimate(points,SpatialPose(),1_000_000_000)!!
|
||||
val right=HandGestures(rightHand=true).estimate(points.map { SpatialVector(-it.x,it.y,it.z) },SpatialPose(),1_000_000_000)!!
|
||||
assertEquals(left.flags(),right.flags());assertEquals(1f,right.trigger,0f);assertTrue(right.grip)
|
||||
assertEquals(left.timeNs,right.timeNs)
|
||||
assertVector(SpatialVector(-left.pose.position.x,left.pose.position.y,left.pose.position.z),right.pose.position)
|
||||
}
|
||||
private fun assertVector(expected: SpatialVector,actual: SpatialVector) {
|
||||
assertEquals(expected.x,actual.x,.0001f);assertEquals(expected.y,actual.y,.0001f);assertEquals(expected.z,actual.z,.0001f)
|
||||
}
|
||||
@Test fun pinchAndFingerClosureProduceTriggerAndGrip() {
|
||||
val detector=HandGestures(rightHand=false);val p=openHand()
|
||||
detector.estimate(p,SpatialPose(),1_000_000_000)
|
||||
p[4]=p[8]
|
||||
for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) p[tip]=p[base]
|
||||
val pressed=detector.estimate(p,SpatialPose(),1_040_000_000)!!
|
||||
assertEquals(1f,pressed.trigger,.0001f);assertTrue(pressed.grip)
|
||||
val released=detector.estimate(openHand(),SpatialPose(),1_080_000_000)!!
|
||||
assertEquals(0f,released.trigger,.0001f);assertFalse(released.grip)
|
||||
}
|
||||
@Test fun invalidGeometryAndImplausibleTemporalJumpAreRejected() {
|
||||
val detector=HandGestures(rightHand=false)
|
||||
assertNull(detector.estimate(emptyList(),SpatialPose(),1))
|
||||
assertEquals(HandObservationOutcome.LANDMARK_COUNT_INVALID,detector.lastOutcome)
|
||||
assertNull(detector.estimate(List(21) { SpatialVector() },SpatialPose(),1))
|
||||
assertEquals(HandObservationOutcome.PALM_WIDTH_INVALID,detector.lastOutcome)
|
||||
detector.estimate(openHand(),SpatialPose(),1_000_000_000)
|
||||
assertNull(detector.estimate(openHand(),SpatialPose(SpatialVector(2f,0f,0f)),1_040_000_000))
|
||||
assertEquals(HandObservationOutcome.PALM_MOTION_REJECTED,detector.lastOutcome)
|
||||
detector.reset()
|
||||
assertNotNull(detector.estimate(openHand(),SpatialPose(SpatialVector(2f,0f,0f)),1_080_000_000))
|
||||
assertEquals(HandObservationOutcome.ACCEPTED,detector.lastOutcome)
|
||||
}
|
||||
@Test fun anUnreliableUnusedJointDoesNotHideThePalmOrDisableGestures() {
|
||||
val points=openHand().map { it as SpatialVector? }.toMutableList()
|
||||
points[6]=null
|
||||
val hand=HandGestures(rightHand=false).estimate(points,SpatialPose(),1_000_000_000)!!
|
||||
assertTrue(hand.valid);assertTrue(hand.triggerValid);assertTrue(hand.gripValid)
|
||||
assertEquals(7,hand.flags())
|
||||
}
|
||||
@Test fun repeatedMotionRejectionsPreserveTheLastPoseAndGripHysteresis() {
|
||||
val detector=HandGestures(false)
|
||||
val closed=openHand().apply {
|
||||
for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) this[tip]=this[base]
|
||||
}
|
||||
assertTrue(detector.estimate(closed,SpatialPose(),1_000_000_000)!!.grip)
|
||||
for(time in listOf(1_040_000_000L,1_080_000_000L,1_120_000_000L)) {
|
||||
assertNull(detector.estimate(openHand(),SpatialPose(SpatialVector(2f,0f,0f)),time))
|
||||
assertEquals(HandObservationOutcome.PALM_MOTION_REJECTED,detector.lastOutcome)
|
||||
detector.resetAfterRejection(detector.lastOutcome)
|
||||
}
|
||||
val partlyClosed=openHand().apply { this[12]=this[9];this[16]=this[13] }
|
||||
val recovered=detector.estimate(partlyClosed,SpatialPose(),1_160_000_000)!!
|
||||
assertTrue(recovered.grip)
|
||||
assertEquals(1_160_000_000L,recovered.timeNs)
|
||||
}
|
||||
@Test fun motionRejectionDoesNotPreventReacquisitionAfterTheMotionWindow() {
|
||||
val detector=HandGestures(false)
|
||||
detector.estimate(openHand(),SpatialPose(),1_000_000_000)
|
||||
val moved=SpatialPose(SpatialVector(2f,0f,0f))
|
||||
for(time in listOf(1_040_000_000L,1_160_000_000L)) {
|
||||
assertNull(detector.estimate(openHand(),moved,time))
|
||||
detector.resetAfterRejection(detector.lastOutcome)
|
||||
}
|
||||
val reacquired=detector.estimate(openHand(),moved,1_200_000_000)!!
|
||||
assertEquals(HandObservationOutcome.ACCEPTED,detector.lastOutcome)
|
||||
assertEquals(1_200_000_000L,reacquired.timeNs)
|
||||
}
|
||||
@Test fun actualDetectionLossClearsMotionHistoryAndGripEvenAfterAMotionRejection() {
|
||||
val detector=HandGestures(false)
|
||||
val closed=openHand().apply {
|
||||
for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) this[tip]=this[base]
|
||||
}
|
||||
assertTrue(detector.estimate(closed,SpatialPose(),1_000_000_000)!!.grip)
|
||||
val moved=SpatialPose(SpatialVector(2f,0f,0f))
|
||||
assertNull(detector.estimate(closed,moved,1_040_000_000))
|
||||
detector.resetAfterRejection(detector.lastOutcome)
|
||||
detector.resetAfterRejection(HandObservationOutcome.NO_MATCHING_DETECTION)
|
||||
val partlyClosed=openHand().apply { this[12]=this[9];this[16]=this[13] }
|
||||
val reacquired=detector.estimate(partlyClosed,moved,1_080_000_000)!!
|
||||
assertFalse(reacquired.grip)
|
||||
}
|
||||
@Test fun occludedPinchKeepsThePalmAndIndependentGrip() {
|
||||
val detector=HandGestures(rightHand=false)
|
||||
val points=openHand().map { it as SpatialVector? }.toMutableList()
|
||||
points[4]=points[8]
|
||||
for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) points[tip]=points[base]
|
||||
assertEquals(1f,detector.estimate(points,SpatialPose(),1_000_000_000)!!.trigger,0f)
|
||||
points[4]=null
|
||||
val hand=detector.estimate(points,SpatialPose(),1_080_000_000)!!
|
||||
assertTrue(hand.valid);assertFalse(hand.triggerValid);assertEquals(0f,hand.trigger,0f)
|
||||
assertTrue(hand.gripValid);assertTrue(hand.grip);assertEquals(5,hand.flags())
|
||||
}
|
||||
@Test fun occludedGripKeepsThePalmAndIndependentPinch() {
|
||||
val points=openHand().map { it as SpatialVector? }.toMutableList()
|
||||
points[4]=points[8];points[16]=SpatialVector(Float.NaN,0f,.5f)
|
||||
val hand=HandGestures(rightHand=false).estimate(points,SpatialPose(),1_000_000_000)!!
|
||||
assertTrue(hand.valid);assertTrue(hand.triggerValid);assertEquals(1f,hand.trigger,0f)
|
||||
assertFalse(hand.gripValid);assertFalse(hand.grip);assertEquals(3,hand.flags())
|
||||
}
|
||||
@Test fun missingPalmStillRejectsTheController() {
|
||||
for(index in listOf(0,5,9,13,17)) {
|
||||
val points=openHand().map { it as SpatialVector? }.toMutableList();points[index]=null
|
||||
val detector=HandGestures(rightHand=false)
|
||||
assertNull(detector.estimate(points,SpatialPose(),1_000_000_000))
|
||||
assertEquals(HandObservationOutcome.PALM_LANDMARK_MISSING,detector.lastOutcome)
|
||||
assertNotNull(detector.estimate(openHand(),SpatialPose(),1_040_000_000))
|
||||
assertEquals(HandObservationOutcome.ACCEPTED,detector.lastOutcome)
|
||||
}
|
||||
assertEquals(0,SpatialHand(triggerValid=true,gripValid=true).flags())
|
||||
}
|
||||
@Test fun degeneratePalmAxesAreDistinguishedFromMissingStereoLandmarks() {
|
||||
val detector=HandGestures(rightHand=false)
|
||||
for(middle in listOf(SpatialVector(0f,0f,.5f),SpatialVector(.04f,0f,.5f))) {
|
||||
val points=openHand().apply { this[9]=middle }
|
||||
assertNull(detector.estimate(points,SpatialPose(),1_000_000_000))
|
||||
assertEquals(HandObservationOutcome.PALM_BASIS_INVALID,detector.lastOutcome)
|
||||
}
|
||||
assertNotNull(detector.estimate(openHand(),SpatialPose(),1_040_000_000))
|
||||
assertEquals(HandObservationOutcome.ACCEPTED,detector.lastOutcome)
|
||||
}
|
||||
@Test fun agreeingImageCurlsAndPinchSurviveMissingTriangulatedFingertips() {
|
||||
val image=openHand().apply {
|
||||
this[4]=this[8]
|
||||
for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) this[tip]=this[base]
|
||||
}.map { SpatialVector(320f+it.x*1000f,240f+it.y*1000f) }
|
||||
val points=openHand().map { it as SpatialVector? }.toMutableList()
|
||||
for(index in listOf(4,8,12,16,20)) points[index]=null
|
||||
val hand=HandGestures(false).estimate(points,SpatialPose(),1_000_000_000,image,image)!!
|
||||
assertTrue(hand.valid);assertTrue(hand.gripValid);assertTrue(hand.grip)
|
||||
assertTrue(hand.triggerValid);assertEquals(1f,hand.trigger,0f)
|
||||
assertVector(HandGestures(false).estimate(openHand(),SpatialPose(),1_000_000_000)!!.pose.position,hand.pose.position)
|
||||
}
|
||||
@Test fun imageDisagreementInvalidatesGestureInsteadOfFallingBackToPressedDepth() {
|
||||
val closed=openHand().apply {
|
||||
this[4]=this[8]
|
||||
for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) this[tip]=this[base]
|
||||
}
|
||||
fun image(points: List<SpatialVector>)=points.map { SpatialVector(it.x*1000f,it.y*1000f) }
|
||||
val detector=HandGestures(false)
|
||||
assertTrue(detector.estimate(closed,SpatialPose(),1_000_000_000,image(closed),image(closed))!!.grip)
|
||||
val conflict=detector.estimate(closed,SpatialPose(),1_080_000_000,image(closed),image(openHand()))!!
|
||||
assertTrue(conflict.valid);assertFalse(conflict.triggerValid);assertFalse(conflict.gripValid)
|
||||
assertFalse(conflict.grip);assertEquals(0f,conflict.trigger,0f)
|
||||
val missingView=detector.estimate(closed,SpatialPose(),1_120_000_000,image(closed),null)!!
|
||||
assertTrue(missingView.valid);assertFalse(missingView.triggerValid);assertFalse(missingView.gripValid)
|
||||
val released=detector.estimate(closed,SpatialPose(),1_160_000_000,image(openHand()),image(openHand()))!!
|
||||
assertTrue(released.triggerValid);assertTrue(released.gripValid)
|
||||
assertFalse(released.grip);assertEquals(0f,released.trigger,0f)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,90 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import android.graphics.Bitmap
|
||||
import android.graphics.Color
|
||||
import com.google.mediapipe.framework.image.ByteBufferExtractor
|
||||
import com.google.mediapipe.framework.image.MPImage
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.annotation.Config
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk=[28],manifest=Config.NONE)
|
||||
class HandImageBufferTest {
|
||||
private fun bitmap(vararg values: Int) = Bitmap.createBitmap(values.size, 1, Bitmap.Config.ARGB_8888).apply {
|
||||
setPixels(values.map { Color.rgb(it, it, it) }.toIntArray(), 0, values.size, 0, 0, values.size, 1)
|
||||
}
|
||||
|
||||
private fun values(buffer: HandImageBuffer, bitmap: Bitmap): List<Int> = values(buffer.image(bitmap))
|
||||
|
||||
private fun values(image: MPImage): List<Int> = image.use {
|
||||
assertEquals(MPImage.IMAGE_FORMAT_RGB, image.containedImageProperties.single().imageFormat)
|
||||
val pixels = ByteBufferExtractor.extract(image)
|
||||
assertTrue(pixels.isDirect)
|
||||
assertEquals(image.width * image.height * 3, pixels.remaining())
|
||||
List(image.width * image.height) {
|
||||
val red = pixels.get().toInt() and 255
|
||||
assertEquals(red, pixels.get().toInt() and 255)
|
||||
assertEquals(red, pixels.get().toInt() and 255)
|
||||
red
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun liveDefaultUsesFullModelAndPreservesCameraPixelCoordinatesAndExposure() {
|
||||
assertEquals(HandModel.FULL, HandModel.DEFAULT)
|
||||
val input = byteArrayOf(32, 64, 96, 128.toByte(), 160.toByte(), 192.toByte())
|
||||
val original = input.copyOf()
|
||||
val image = HandImageBuffer().image(input, 3, 2)
|
||||
assertEquals(3, image.width); assertEquals(2, image.height)
|
||||
assertEquals(listOf(32, 64, 96, 128, 160, 192), values(image))
|
||||
assertArrayEquals(original, input)
|
||||
}
|
||||
|
||||
@Test fun directCameraAndRawBitmapInputsMatchAcrossEveryGrayValueAndFrameSize() {
|
||||
val buffer = HandImageBuffer()
|
||||
for ((width, height) in listOf(16 to 16, 3 to 2, 2 to 3, 1 to 1)) {
|
||||
val input = ByteArray(width * height) { ((it * 73 + 32) and 255).toByte() }
|
||||
val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888).apply {
|
||||
setPixels(input.map { (it.toInt() and 255).let { value -> Color.rgb(value, value, value) } }.toIntArray(),
|
||||
0, width, 0, 0, width, height)
|
||||
}
|
||||
try {
|
||||
val expected = input.map { it.toInt() and 255 }
|
||||
assertEquals(expected, values(buffer.image(input, width, height)))
|
||||
assertEquals(expected, values(buffer.image(bitmap)))
|
||||
} finally { bitmap.recycle() }
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException::class)
|
||||
fun cameraDimensionsMustMatchTheGrayscaleFrame() {
|
||||
HandImageBuffer().image(ByteArray(5), 3, 2)
|
||||
}
|
||||
|
||||
@Test fun resizedAndSuccessiveFramesDoNotRetainOldPixelsOrExposure() {
|
||||
val buffer = HandImageBuffer()
|
||||
for (input in listOf(intArrayOf(32, 96, 160), intArrayOf(64, 128, 192), intArrayOf(0, 255))) {
|
||||
val bitmap = bitmap(*input)
|
||||
try {
|
||||
assertEquals(input.toList(), values(buffer, bitmap))
|
||||
} finally { bitmap.recycle() }
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun closingInferenceImagesDoesNotRecycleReusableCameraBitmap() {
|
||||
val bitmap=Bitmap.createBitmap(2,2,Bitmap.Config.ARGB_8888)
|
||||
val buffer=HandImageBuffer()
|
||||
repeat(3) { frame ->
|
||||
bitmap.eraseColor(if(frame%2==0) Color.WHITE else Color.BLACK)
|
||||
buffer.image(bitmap).use { image ->
|
||||
assertEquals(2,image.width);assertEquals(2,image.height)
|
||||
val pixels=ByteBufferExtractor.extract(image)
|
||||
assertEquals(if(frame%2==0) 255 else 0,pixels.get(0).toInt() and 255)
|
||||
}
|
||||
assertFalse(bitmap.isRecycled)
|
||||
}
|
||||
bitmap.recycle()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
|
||||
class HandInferenceScheduleTest {
|
||||
private fun frame(schedule: HandInferenceSchedule, time: Long, left: List<Int> = listOf(0),
|
||||
right: List<Int> = left, rawLeft: Int = left.size, rawRight: Int = right.size): Int {
|
||||
val maximum = schedule.select(time)
|
||||
schedule.observe(time, left, right, rawLeft, rawRight)
|
||||
return maximum
|
||||
}
|
||||
|
||||
private fun stable(schedule: HandInferenceSchedule, side: Int = 0) {
|
||||
for (time in listOf(0L, 80L, 160L)) assertEquals(2, frame(schedule, time, listOf(side)))
|
||||
}
|
||||
|
||||
@Test fun requiresThreeStereoConsistentFramesBeforeSingleHandTracking() {
|
||||
val schedule = HandInferenceSchedule()
|
||||
stable(schedule)
|
||||
assertEquals(1, frame(schedule, 240))
|
||||
assertEquals(1, frame(schedule, 320))
|
||||
assertEquals(2, frame(schedule, 400))
|
||||
assertEquals(1, frame(schedule, 480))
|
||||
}
|
||||
|
||||
@Test fun discoversSecondHandAtBothCameraInputCadences() {
|
||||
for (cadence in listOf(40L, 80L)) {
|
||||
val schedule = HandInferenceSchedule()
|
||||
val searches = ArrayList<Long>()
|
||||
for (time in 0L..1200L step cadence) {
|
||||
if (frame(schedule, time) == 2) searches.add(time)
|
||||
}
|
||||
assertTrue(searches.size >= 5)
|
||||
assertTrue(searches.zipWithNext().all { (first, second) -> second - first <= 240 })
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun delayedFrameStillSearchesAtFirstFrameAfterDiscoveryDeadline() {
|
||||
val schedule = HandInferenceSchedule()
|
||||
stable(schedule)
|
||||
assertEquals(1, frame(schedule, 240))
|
||||
assertEquals(1, frame(schedule, 399))
|
||||
assertEquals(2, frame(schedule, 479))
|
||||
assertEquals(1, frame(schedule, 559))
|
||||
}
|
||||
|
||||
@Test fun secondHandDiscoveredBySearchKeepsBothHandDetectorsSelected() {
|
||||
val schedule = HandInferenceSchedule()
|
||||
stable(schedule)
|
||||
assertEquals(1, frame(schedule, 240))
|
||||
assertEquals(2, frame(schedule, 400, listOf(0, 1)))
|
||||
for (time in listOf(480L, 560L, 640L)) assertEquals(2, frame(schedule, time, listOf(1, 0)))
|
||||
for (time in listOf(720L, 800L, 880L)) assertEquals(2, frame(schedule, time))
|
||||
assertEquals(1, frame(schedule, 960))
|
||||
}
|
||||
|
||||
@Test fun anyCameraLossImmediatelyReturnsToFullSearch() {
|
||||
for ((left, right) in listOf(emptyList<Int>() to listOf(0), listOf(0) to emptyList())) {
|
||||
val schedule = HandInferenceSchedule()
|
||||
stable(schedule)
|
||||
assertEquals(1, frame(schedule, 240, left, right))
|
||||
assertEquals(2, frame(schedule, 320))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun ambiguousOrFilteredDetectionsNeverMaintainSingleHandMode() {
|
||||
val invalid = listOf(
|
||||
listOf(0) to listOf(1),
|
||||
listOf(0, 0) to listOf(0),
|
||||
listOf(0) to listOf(0, 0),
|
||||
listOf(-1) to listOf(-1),
|
||||
listOf(2) to listOf(2)
|
||||
)
|
||||
for ((left, right) in invalid) {
|
||||
val schedule = HandInferenceSchedule()
|
||||
stable(schedule)
|
||||
frame(schedule, 240, left, right)
|
||||
assertEquals(2, frame(schedule, 320))
|
||||
}
|
||||
for ((rawLeft, rawRight) in listOf(2 to 1, 1 to 2, 0 to 1, -1 to 1)) {
|
||||
val schedule = HandInferenceSchedule()
|
||||
stable(schedule)
|
||||
frame(schedule, 240, rawLeft = rawLeft, rawRight = rawRight)
|
||||
assertEquals(2, frame(schedule, 320))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun changingSidesRequiresFreshFullSearchStability() {
|
||||
val schedule = HandInferenceSchedule()
|
||||
stable(schedule)
|
||||
assertEquals(1, frame(schedule, 240, listOf(1)))
|
||||
for (time in listOf(320L, 400L, 480L)) assertEquals(2, frame(schedule, time, listOf(1)))
|
||||
assertEquals(1, frame(schedule, 560, listOf(1)))
|
||||
}
|
||||
|
||||
@Test fun inconsistentInitialSidesCannotAccumulateStability() {
|
||||
val schedule = HandInferenceSchedule()
|
||||
for (index in 0..8) assertEquals(2, frame(schedule, index * 80L, listOf(index % 2)))
|
||||
}
|
||||
|
||||
@Test fun resetDropsSessionState() {
|
||||
val schedule = HandInferenceSchedule()
|
||||
stable(schedule)
|
||||
frame(schedule, 240)
|
||||
schedule.reset()
|
||||
stable(schedule, 1)
|
||||
assertEquals(1, frame(schedule, 240, listOf(1)))
|
||||
}
|
||||
|
||||
@Test fun longGapAndNonmonotonicTimeRequireFreshStability() {
|
||||
for (time in listOf(160L, 120L, 561L, -1L)) {
|
||||
val schedule = HandInferenceSchedule()
|
||||
stable(schedule)
|
||||
assertEquals(2, frame(schedule, time))
|
||||
assertEquals(2, frame(schedule, maxOf(0, time) + 80))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun unobservedInferenceAndMismatchedObservationResetSchedule() {
|
||||
val schedule = HandInferenceSchedule()
|
||||
stable(schedule)
|
||||
assertEquals(1, schedule.select(240))
|
||||
assertEquals(2, frame(schedule, 320))
|
||||
schedule.observe(240, listOf(0), listOf(0))
|
||||
assertEquals(2, frame(schedule, 400))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
|
||||
class HandObservationTest {
|
||||
private val time=1_000_000_000L
|
||||
private fun session()=SpatialSession().apply {
|
||||
reset(7,1.6f)
|
||||
accept(SpatialSample(SpatialPose(),time,7,true))
|
||||
}
|
||||
private fun advance(session: SpatialSession, ms: Long, valid: Boolean=true, x: Float=.1f) {
|
||||
session.accept(SpatialSample(SpatialPose(SpatialVector(x=x)),time+ms*1_000_000,7,valid))
|
||||
}
|
||||
|
||||
@Test fun lateCameraConfirmationUsesTheCapturePoseInsteadOfTheLatestPose() {
|
||||
val session=session()
|
||||
val observation=HandObservation(time,7,session.trackingFrameGeneration)
|
||||
assertNull(observation.headPose(session,false,time))
|
||||
advance(session,150)
|
||||
assertEquals(SpatialPose(),observation.headPose(session,true,time+150_000_000))
|
||||
assertEquals(time,observation.timeNs)
|
||||
}
|
||||
|
||||
@Test fun missingConfirmationOrExpiredObservationCannotPublish() {
|
||||
val session=session()
|
||||
val observation=HandObservation(time,7,session.trackingFrameGeneration)
|
||||
advance(session,180)
|
||||
assertNull(observation.headPose(session,false,time+180_000_000))
|
||||
assertNotNull(observation.headPose(session,true,time+200_000_000))
|
||||
assertNull(observation.headPose(session,true,time+200_000_001))
|
||||
assertNull(observation.headPose(session,true,time-1))
|
||||
}
|
||||
|
||||
@Test fun longerHandWindowDoesNotExtendHeadFreshness() {
|
||||
val session=session()
|
||||
val observation=HandObservation(time,7,session.trackingFrameGeneration)
|
||||
assertNotNull(observation.headPose(session,true,time+100_000_000))
|
||||
assertNull(observation.headPose(session,true,time+100_000_001))
|
||||
advance(session,150)
|
||||
assertNotNull(observation.headPose(session,true,time+150_000_000))
|
||||
}
|
||||
|
||||
@Test fun trackingLossAndRecoveredDiscontinuityInvalidateInFlightInference() {
|
||||
val session=session()
|
||||
val observation=HandObservation(time,7,session.trackingFrameGeneration)
|
||||
advance(session,20,valid=false)
|
||||
assertNull(observation.headPose(session,true,time+20_000_000))
|
||||
advance(session,30,x=5f)
|
||||
assertNull(observation.headPose(session,true,time+30_000_000))
|
||||
session.setFloor(1.6f,time+30_000_000)
|
||||
assertTrue(session.valid(time+30_000_000))
|
||||
assertNull(observation.headPose(session,true,time+30_000_000))
|
||||
}
|
||||
|
||||
@Test fun reconnectAndMissingHistoryCannotBorrowAnotherPose() {
|
||||
val session=session()
|
||||
val observation=HandObservation(time,7,session.trackingFrameGeneration)
|
||||
advance(session,40)
|
||||
assertNull(observation.copy(timeNs=time+20_000_000).headPose(session,true,time+40_000_000))
|
||||
session.reset(8,1.6f)
|
||||
session.accept(SpatialSample(SpatialPose(),time+50_000_000,8,true))
|
||||
assertNull(observation.headPose(session,true,time+50_000_000))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
|
||||
class HandProcessingRateTest {
|
||||
private fun sample(rate: HandProcessingRate, processingMs: Long = 35, ageMs: Long = 65,
|
||||
healthy: Boolean = true): Int =
|
||||
rate.observe(processingMs * 1_000_000, ageMs * 1_000_000, healthy)
|
||||
|
||||
private fun fastest(rate: HandProcessingRate) {
|
||||
repeat(16) { sample(rate) }
|
||||
assertEquals(800, rate.permille)
|
||||
}
|
||||
|
||||
@Test fun beginsConservativelyAndRequiresEightHealthySamplesPerIncrease() {
|
||||
val rate = HandProcessingRate()
|
||||
assertEquals(500, rate.permille)
|
||||
repeat(7) { assertEquals(500, sample(rate)) }
|
||||
assertEquals(600, sample(rate))
|
||||
repeat(7) { assertEquals(600, sample(rate)) }
|
||||
assertEquals(800, sample(rate))
|
||||
repeat(20) { assertEquals(800, sample(rate)) }
|
||||
}
|
||||
|
||||
@Test fun onlySelectsFifteenHzWhenTwentyHzHasInsufficientHeadroom() {
|
||||
val rate = HandProcessingRate()
|
||||
repeat(8) { sample(rate, 50, 80) }
|
||||
assertEquals(600, rate.permille)
|
||||
repeat(30) { assertEquals(600, sample(rate, 50, 80)) }
|
||||
}
|
||||
|
||||
@Test fun slowProcessingStaysAtTwelvePointFiveHz() {
|
||||
val rate = HandProcessingRate()
|
||||
repeat(30) { assertEquals(500, sample(rate, 60, 100)) }
|
||||
}
|
||||
|
||||
@Test fun sustainedProcessingPastTheCurrentPeriodReducesRate() {
|
||||
val rate = HandProcessingRate()
|
||||
fastest(rate)
|
||||
repeat(2) { assertEquals(800, sample(rate, 70)) }
|
||||
assertEquals(600, sample(rate, 70))
|
||||
repeat(7) { assertEquals(600, sample(rate, 70)) }
|
||||
assertEquals(500, sample(rate, 70))
|
||||
repeat(7) { assertEquals(500, sample(rate)) }
|
||||
}
|
||||
|
||||
@Test fun largeProcessingSpikeSkipsDirectlyToConservativeRate() {
|
||||
val rate = HandProcessingRate()
|
||||
fastest(rate)
|
||||
assertEquals(500, sample(rate, 80, 100))
|
||||
}
|
||||
|
||||
@Test fun ageLimitReducesRateWithoutWaitingForProcessingAverage() {
|
||||
val rate = HandProcessingRate()
|
||||
fastest(rate)
|
||||
assertEquals(500, sample(rate, ageMs = 140))
|
||||
repeat(7) { assertEquals(500, sample(rate)) }
|
||||
assertEquals(600, sample(rate))
|
||||
}
|
||||
|
||||
@Test fun agingFramesCannotRaiseTheRate() {
|
||||
val rate = HandProcessingRate()
|
||||
repeat(30) { assertEquals(500, sample(rate, ageMs = 111)) }
|
||||
repeat(8) { sample(rate, ageMs = 100) }
|
||||
assertEquals(600, rate.permille)
|
||||
repeat(30) { assertEquals(600, sample(rate, ageMs = 91)) }
|
||||
}
|
||||
|
||||
@Test fun marginalHeadroomInterruptsConsecutiveUpshiftSamples() {
|
||||
val rate = HandProcessingRate()
|
||||
repeat(7) { sample(rate, 55) }
|
||||
assertEquals(500, sample(rate, 60))
|
||||
repeat(7) { assertEquals(500, sample(rate)) }
|
||||
assertEquals(600, sample(rate))
|
||||
}
|
||||
|
||||
@Test fun recoveryMustAlsoBringAverageProcessingBelowUpshiftThreshold() {
|
||||
val rate = HandProcessingRate()
|
||||
sample(rate, 100)
|
||||
repeat(8) { assertEquals(500, sample(rate)) }
|
||||
repeat(8) { sample(rate) }
|
||||
assertEquals(600, rate.permille)
|
||||
}
|
||||
|
||||
@Test fun trackingLossAndInvalidTimingResetTheRateAndHistory() {
|
||||
for (invalid in listOf(Triple(35_000_000L, 65_000_000L, false),
|
||||
Triple(0L, 65_000_000L, true), Triple(-1L, 65_000_000L, true),
|
||||
Triple(35_000_000L, -1L, true))) {
|
||||
val rate = HandProcessingRate()
|
||||
fastest(rate)
|
||||
assertEquals(500, rate.observe(invalid.first, invalid.second, invalid.third))
|
||||
repeat(7) { assertEquals(500, sample(rate)) }
|
||||
assertEquals(600, sample(rate))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun lifecycleResetDropsOldHeadroom() {
|
||||
val rate = HandProcessingRate()
|
||||
fastest(rate)
|
||||
assertEquals(500, rate.reset())
|
||||
repeat(7) { assertEquals(500, sample(rate)) }
|
||||
assertEquals(600, sample(rate))
|
||||
}
|
||||
|
||||
@Test fun periodicDiscoverySearchesPermitFifteenHzButNotTwentyHz() {
|
||||
val rate = HandProcessingRate()
|
||||
repeat(8) { sample(rate, if (it % 3 == 2) 74 else 36, 90) }
|
||||
assertEquals(600, rate.permille)
|
||||
for (frame in 8 until 90) {
|
||||
assertEquals(600, sample(rate, if (frame % 3 == 2) 74 else 36, 90))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun continuouslySlowDiscoveryCannotRaiseRate() {
|
||||
val rate = HandProcessingRate()
|
||||
repeat(30) { assertEquals(500, sample(rate, 70, 100)) }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
|
||||
class HandTrackingMetricsTest {
|
||||
private val missing = HandObservationDiagnostic(HandObservationOutcome.NO_MATCHING_DETECTION)
|
||||
private fun accepted(trigger: Float = 0f, grip: Boolean = false) = HandObservationDiagnostic(
|
||||
HandObservationOutcome.ACCEPTED, listOf(0,5,9,13,17), trigger, true, grip, true)
|
||||
|
||||
@Test fun cameraSequencesCountOnceAndSkippedPairsAreNotInvented() {
|
||||
val metrics = HandTrackingMetrics()
|
||||
metrics.observe(0, true, accepted(), accepted())
|
||||
metrics.observe(10, true, accepted(), missing)
|
||||
metrics.observe(10, true, missing, accepted())
|
||||
metrics.observe(9, true, missing, accepted())
|
||||
metrics.observe(15, true, accepted(), missing)
|
||||
val result = metrics.snapshot()
|
||||
assertEquals(2L, result.processedPairs)
|
||||
assertEquals(2L, result.inferencePairs)
|
||||
assertEquals(2L, result.left.accepted)
|
||||
assertEquals(0L, result.right.accepted)
|
||||
assertEquals(2L, result.right.observations)
|
||||
assertEquals(0L, result.left.trackingLosses)
|
||||
}
|
||||
|
||||
@Test fun setupAndUnavailableFramesRemainDistinctFromInference() {
|
||||
val metrics = HandTrackingMetrics()
|
||||
val setup = HandObservationDiagnostic(HandObservationOutcome.CALIBRATION_REQUIRED)
|
||||
val unavailable = HandObservationDiagnostic(HandObservationOutcome.INFERENCE_UNAVAILABLE)
|
||||
metrics.observe(1, false, setup, setup)
|
||||
metrics.observe(2, false, unavailable, unavailable)
|
||||
metrics.observe(3, true, accepted(), missing)
|
||||
val result = metrics.snapshot()
|
||||
assertEquals(3L, result.processedPairs)
|
||||
assertEquals(1L, result.inferencePairs)
|
||||
assertEquals(3L, result.left.observations)
|
||||
assertEquals(1L, result.left.accepted)
|
||||
assertEquals(1L, result.left.outcomes[HandObservationOutcome.CALIBRATION_REQUIRED])
|
||||
assertEquals(1L, result.left.outcomes[HandObservationOutcome.INFERENCE_UNAVAILABLE])
|
||||
assertEquals(3L, result.right.maximumConsecutiveRejected)
|
||||
}
|
||||
|
||||
@Test fun countsGestureLossesIndependentlyFromPalmLossAndOtherHand() {
|
||||
val metrics = HandTrackingMetrics()
|
||||
metrics.observe(1, true, accepted(), accepted())
|
||||
metrics.observe(2, true, accepted().copy(triggerGeometryValid = false), accepted())
|
||||
metrics.observe(3, true, accepted().copy(gripGeometryValid = false), accepted())
|
||||
metrics.observe(4, true, missing, accepted())
|
||||
metrics.observe(5, true, missing, accepted())
|
||||
val result = metrics.snapshot()
|
||||
assertEquals(3L, result.left.accepted)
|
||||
assertEquals(1L, result.left.trackingLosses)
|
||||
assertEquals(2L, result.left.triggerLosses)
|
||||
assertEquals(1L, result.left.gripLosses)
|
||||
assertEquals(2L, result.left.maximumConsecutiveRejected)
|
||||
assertEquals(0L, result.right.trackingLosses)
|
||||
assertEquals(0L, result.right.triggerLosses)
|
||||
assertEquals(0L, result.right.gripLosses)
|
||||
}
|
||||
|
||||
@Test fun rejectedObservationRetainsRawEstimatesButCannotCountUsableInputs() {
|
||||
val metrics = HandTrackingMetrics()
|
||||
val stale = accepted(1f, true).copy(outcome = HandObservationOutcome.STALE_OBSERVATION)
|
||||
assertEquals(1f, stale.triggerEstimate, 0f)
|
||||
assertTrue(stale.gripEstimate)
|
||||
assertTrue(stale.triggerGeometryValid)
|
||||
assertFalse(stale.accepted)
|
||||
assertFalse(stale.triggerValid)
|
||||
assertFalse(stale.gripValid)
|
||||
metrics.observe(1, true, stale, stale)
|
||||
val side = metrics.snapshot().left
|
||||
assertEquals(0L, side.accepted)
|
||||
assertEquals(0L, side.triggerValid)
|
||||
assertEquals(0L, side.gripValid)
|
||||
assertEquals(0L, side.triggerAboveClickThreshold)
|
||||
assertEquals(0L, side.gripPressed)
|
||||
}
|
||||
|
||||
@Test fun thresholdCountsDescribeValidEstimatesWithoutClaimingDriverPresses() {
|
||||
val metrics = HandTrackingMetrics()
|
||||
for ((index, trigger) in listOf(0f, .25f, .65f, 1f).withIndex())
|
||||
metrics.observe(index + 1L, true, accepted(trigger, index == 3), missing)
|
||||
metrics.observe(5, true, accepted(1f, true).copy(triggerGeometryValid = false, gripGeometryValid = false), missing)
|
||||
val side = metrics.snapshot().left
|
||||
assertEquals(5L, side.accepted)
|
||||
assertEquals(4L, side.triggerValid)
|
||||
assertEquals(4L, side.gripValid)
|
||||
assertEquals(1L, side.triggerAboveClickThreshold)
|
||||
assertEquals(1L, side.triggerReleased)
|
||||
assertEquals(1L, side.gripPressed)
|
||||
}
|
||||
|
||||
@Test fun snapshotsRetainTheirCountsWhenLaterFramesArrive() {
|
||||
val metrics = HandTrackingMetrics()
|
||||
metrics.observe(1, true, accepted(), missing)
|
||||
val first = metrics.snapshot()
|
||||
metrics.observe(2, true, missing, accepted())
|
||||
assertEquals(1L, first.processedPairs)
|
||||
assertEquals(mapOf(HandObservationOutcome.ACCEPTED to 1L), first.left.outcomes)
|
||||
assertEquals(0L, first.left.trackingLosses)
|
||||
assertEquals(2L, metrics.snapshot().processedPairs)
|
||||
assertEquals(1L, metrics.snapshot().left.trackingLosses)
|
||||
}
|
||||
|
||||
@Test fun aNewTrackingConnectionStartsCountsAndSequenceFromZero() {
|
||||
val old = HandTrackingMetrics()
|
||||
old.observe(500, true, accepted(), missing)
|
||||
old.observe(501, true, missing, missing)
|
||||
val current = HandTrackingMetrics()
|
||||
assertEquals(0L, current.snapshot().processedPairs)
|
||||
current.observe(1, true, accepted(), accepted())
|
||||
val result = current.snapshot()
|
||||
assertEquals(1L, result.processedPairs)
|
||||
assertEquals(1L, result.left.accepted)
|
||||
assertEquals(0L, result.left.trackingLosses)
|
||||
assertEquals(0L, result.right.maximumConsecutiveRejected)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
|
||||
class JoyConFlowGateTest {
|
||||
@Test fun missingDetectionsCannotExtendTheSeedLifetime() {
|
||||
val seed = 1_000_000_000L
|
||||
assertTrue(JoyConFlowGate.fresh(seed, seed + 640_000_000, seed + 720_000_000))
|
||||
assertFalse(JoyConFlowGate.fresh(seed, seed + 720_000_000, seed + 800_000_000))
|
||||
assertFalse(JoyConFlowGate.fresh(seed, seed, seed + 200_000_001))
|
||||
assertFalse(JoyConFlowGate.fresh(seed, seed, seed))
|
||||
}
|
||||
|
||||
@Test fun featureMustBeVisibleAndReturnToItsOriginalLocation() {
|
||||
assertTrue(JoyConFlowGate.point(110.0,105.0,100.5,100.5,100.0,100.0,5f,true,true,640,480))
|
||||
assertFalse(JoyConFlowGate.point(110.0,105.0,103.0,100.0,100.0,100.0,5f,true,true,640,480))
|
||||
assertFalse(JoyConFlowGate.point(110.0,105.0,100.0,100.0,100.0,100.0,30f,true,true,640,480))
|
||||
assertFalse(JoyConFlowGate.point(110.0,105.0,100.0,100.0,100.0,100.0,5f,false,true,640,480))
|
||||
assertFalse(JoyConFlowGate.point(Double.NaN,105.0,100.0,100.0,100.0,100.0,5f,true,true,640,480))
|
||||
assertFalse(JoyConFlowGate.point(640.0,105.0,100.0,100.0,100.0,100.0,5f,true,true,640,480))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
|
||||
class JoyConWristPositionTest {
|
||||
private fun points(depth: Float = .4f): MutableList<SpatialVector?> = MutableList<SpatialVector?>(21) { null }.apply {
|
||||
this[0] = SpatialVector(0f, 0f, depth)
|
||||
this[5] = SpatialVector(.035f, -.06f, depth)
|
||||
this[9] = SpatialVector(0f, -.065f, depth)
|
||||
this[13] = SpatialVector(-.02f, -.06f, depth)
|
||||
this[17] = SpatialVector(-.045f, -.05f, depth)
|
||||
}
|
||||
|
||||
@Test fun grippingControllerNeedsOnlyTheWristAndNeverGeneratesFingerGestures() {
|
||||
val estimator = JoyConWristPosition()
|
||||
val full = estimator.estimate(points(), SpatialPose(), 1_000_000_000)!!
|
||||
val occluded = MutableList<SpatialVector?>(21) { null }.apply { this[0] = points()[0] }
|
||||
val grip = estimator.estimate(occluded, SpatialPose(), 1_080_000_000)!!
|
||||
assertEquals(occluded[0], grip.pose.position)
|
||||
assertEquals(full.pose.position, grip.pose.position)
|
||||
assertTrue(grip.valid)
|
||||
assertFalse(grip.triggerValid)
|
||||
assertFalse(grip.gripValid)
|
||||
assertNull(HandGestures(false).estimate(occluded, SpatialPose(), 1_080_000_000))
|
||||
}
|
||||
|
||||
@Test fun erroneousKnucklesCannotMoveOrRejectTheWrist() {
|
||||
val malformed = points().apply {
|
||||
this[5] = SpatialVector(Float.NaN, 0f, .4f)
|
||||
this[9] = SpatialVector(4f, 5f, 6f)
|
||||
this[13] = this[0]
|
||||
this[17] = null
|
||||
}
|
||||
val grip = JoyConWristPosition().estimate(malformed, SpatialPose(), 1)!!
|
||||
assertEquals(malformed[0], grip.pose.position)
|
||||
}
|
||||
|
||||
@Test fun measuredExtensionMovesTheWorldPositionByTheSameDistance() {
|
||||
val estimator = JoyConWristPosition()
|
||||
val world = SpatialPose(SpatialVector(1f, 2f, 3f), SpatialRotation(y = 1f, w = 0f))
|
||||
val near = estimator.estimate(points(.3f).take(1), world, 1_000_000_000)!!
|
||||
val far = estimator.estimate(points(.7f).take(1), world, 1_300_000_000)!!
|
||||
assertEquals(SpatialVector(1f, 2f, 2.7f), near.pose.position)
|
||||
assertEquals(-.4f, far.pose.position.z - near.pose.position.z, .0001f)
|
||||
assertEquals(near.pose.position.x, far.pose.position.x, .0001f)
|
||||
assertEquals(1_300_000_000, far.timeNs)
|
||||
}
|
||||
|
||||
@Test fun missingOrNonfiniteWristIsRejectedEvenWithVisibleKnuckles() {
|
||||
for (wrist in listOf(null, SpatialVector(Float.NaN, 0f, .4f), SpatialVector(0f, 0f, Float.POSITIVE_INFINITY))) {
|
||||
val estimator = JoyConWristPosition()
|
||||
assertNull(estimator.estimate(points().apply { this[0] = wrist }, SpatialPose(), 1))
|
||||
assertEquals(HandObservationOutcome.WRIST_LANDMARK_MISSING, estimator.lastOutcome)
|
||||
}
|
||||
assertNull(JoyConWristPosition().estimate(emptyList(), SpatialPose(), 1))
|
||||
}
|
||||
|
||||
@Test fun implausibleJumpsAndRepeatedFramesStayRejectedWithoutPoisoningTheLastPosition() {
|
||||
val estimator = JoyConWristPosition()
|
||||
assertNotNull(estimator.estimate(points(), SpatialPose(), 1_000_000_000))
|
||||
assertNull(estimator.estimate(points(1.2f), SpatialPose(), 1_080_000_000))
|
||||
assertEquals(HandObservationOutcome.WRIST_MOTION_REJECTED, estimator.lastOutcome)
|
||||
assertNull(estimator.estimate(points(), SpatialPose(), 1_000_000_000))
|
||||
assertNotNull(estimator.estimate(points(.45f).take(1), SpatialPose(), 1_090_000_000))
|
||||
estimator.reset()
|
||||
assertNotNull(estimator.estimate(points(1.2f).take(1), SpatialPose(), 1_100_000_000))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import android.app.Application
|
||||
import android.os.SystemClock
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.json.JSONObject
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.RuntimeEnvironment
|
||||
import org.robolectric.annotation.Config
|
||||
import java.io.File
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(application = Application::class)
|
||||
class LumaRgbDiagnosticTest {
|
||||
private val context get() = RuntimeEnvironment.getApplication()
|
||||
private val statusFile get() = File(context.filesDir, "spatial/rgb-diagnostic.json")
|
||||
|
||||
@Before fun reset() { statusFile.delete(); statusFile.parentFile?.mkdirs() }
|
||||
|
||||
@Test fun aDeadWorkerOrPreviousBootCannotLeaveCapturePermanentlyBusy() {
|
||||
for (started in listOf(SystemClock.elapsedRealtime() - 16_000, SystemClock.elapsedRealtime() + 5_000)) {
|
||||
statusFile.writeText("""{"state":"capturing","startedMs":$started}""")
|
||||
assertEquals("failed", LumaRgbDiagnostic.status(context).getString("state"))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun onlyPendingCapturesExpire() {
|
||||
statusFile.writeText("""{"state":"completed","path":"saved-capture"}""")
|
||||
assertEquals("completed", LumaRgbDiagnostic.status(context).getString("state"))
|
||||
statusFile.writeText("""{"state":"capturing","startedMs":${SystemClock.elapsedRealtime()}}""")
|
||||
assertEquals("capturing", LumaRgbDiagnostic.status(context).getString("state"))
|
||||
}
|
||||
|
||||
@Test fun longerReliabilityCaptureRemainsBusyUntilItsBoundedDeadline() {
|
||||
val started = SystemClock.elapsedRealtime() - 20_000
|
||||
statusFile.writeText("""{"state":"capturing","startedMs":$started,"timeoutMs":45000}""")
|
||||
assertEquals("capturing", LumaRgbDiagnostic.status(context).getString("state"))
|
||||
statusFile.writeText("""{"state":"capturing","startedMs":${started-30_000},"timeoutMs":999999}""")
|
||||
assertEquals("failed", LumaRgbDiagnostic.status(context).getString("state"))
|
||||
}
|
||||
|
||||
@Test fun terminalResultWaitsForWorkerExitBeforeAnotherRequest() {
|
||||
for (result in listOf("completed","failed")) {
|
||||
val record=JSONObject().put("state",result).put("workerPid",123).put("startedMs",1000)
|
||||
val finishing=LumaRgbDiagnostic.resolveStatus(JSONObject(record.toString()),2000,true)
|
||||
assertEquals("capturing",finishing.getString("state"))
|
||||
assertEquals("finishing",finishing.getString("phase"))
|
||||
assertEquals(result,finishing.getString("resultState"))
|
||||
assertTrue(finishing.getBoolean("busy"))
|
||||
val exited=LumaRgbDiagnostic.resolveStatus(record,2000,false)
|
||||
assertEquals(result,exited.getString("state"))
|
||||
assertFalse(exited.getBoolean("busy"))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun deadWorkerFailsImmediatelyAndExpiredWorkerRemainsBusyOnlyUntilExit() {
|
||||
val record=JSONObject().put("state","capturing").put("workerPid",123).put("startedMs",1000)
|
||||
val dead=LumaRgbDiagnostic.resolveStatus(JSONObject(record.toString()),2000,false)
|
||||
assertEquals("failed",dead.getString("state"))
|
||||
assertFalse(dead.getBoolean("busy"))
|
||||
val expired=LumaRgbDiagnostic.resolveStatus(JSONObject(record.toString()),17000,true)
|
||||
assertEquals("failed",expired.getString("state"))
|
||||
assertTrue(expired.getBoolean("busy"))
|
||||
val exited=LumaRgbDiagnostic.resolveStatus(record,17000,false)
|
||||
assertEquals("failed",exited.getString("state"))
|
||||
assertFalse(exited.getBoolean("busy"))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import java.nio.ByteBuffer
|
||||
import java.nio.ByteOrder
|
||||
import org.junit.After
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.annotation.Config
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [28], manifest = Config.NONE)
|
||||
class SpatialControllerModeTest {
|
||||
private fun snapshot(): ByteBuffer = (SpatialTracking::class.java.getDeclaredField("buffer")
|
||||
.apply { isAccessible = true }.get(null) as ByteBuffer).duplicate().order(ByteOrder.LITTLE_ENDIAN)
|
||||
|
||||
@After fun cleanUp() {
|
||||
SpatialTracking.setSteadyHandAim(false)
|
||||
SpatialTracking.setControllers(false, false)
|
||||
SpatialTracking.disconnect()
|
||||
}
|
||||
|
||||
@Test fun joyConModeStartsStereoWithoutSelectingGestureControllersAndPersistsAcrossLoss() {
|
||||
SpatialTracking.connect(0, 1, null, true, 1.6f, false, true)
|
||||
assertTrue(SpatialTracking.handsEnabled)
|
||||
assertEquals(4, snapshot().getInt(4))
|
||||
assertEquals(5, snapshot().getInt(32))
|
||||
SpatialTracking.disconnect()
|
||||
assertFalse(SpatialTracking.handsEnabled)
|
||||
assertEquals(5, snapshot().getInt(32))
|
||||
assertEquals(0, snapshot().getInt(76))
|
||||
SpatialTracking.setControllers(false, false)
|
||||
assertEquals(1, snapshot().getInt(32))
|
||||
}
|
||||
|
||||
@Test fun steadyAimIsOptInAndOnlyAppliesToBareHands() {
|
||||
assertFalse(GlassesSettings().steadyHandAim)
|
||||
SpatialTracking.connect(0, 4, null, true, 1.6f, true)
|
||||
assertEquals(3, snapshot().getInt(32))
|
||||
SpatialTracking.setSteadyHandAim(true)
|
||||
assertEquals(11, snapshot().getInt(32))
|
||||
SpatialTracking.setControllers(false, true)
|
||||
assertEquals(5, snapshot().getInt(32))
|
||||
SpatialTracking.setControllers(true, false)
|
||||
assertEquals(11, snapshot().getInt(32))
|
||||
SpatialTracking.setSteadyHandAim(false)
|
||||
assertEquals(3, snapshot().getInt(32))
|
||||
SpatialTracking.connect(0, 5, null, true, 1.6f, true, steadyAim = true)
|
||||
assertEquals(11, snapshot().getInt(32))
|
||||
SpatialTracking.useLegacyTracking()
|
||||
assertEquals(0, snapshot().getInt(32))
|
||||
}
|
||||
|
||||
@Test fun openingOtherGlassesClearsTheRetainedUltraMode() {
|
||||
SpatialTracking.connect(0, 3, null, true, 1.6f, false, true)
|
||||
SpatialTracking.disconnect()
|
||||
assertEquals(5, snapshot().getInt(32))
|
||||
SpatialTracking.useLegacyTracking()
|
||||
assertEquals(0, snapshot().getInt(32))
|
||||
assertFalse(SpatialTracking.enabled)
|
||||
assertFalse(SpatialTracking.handsEnabled)
|
||||
}
|
||||
|
||||
@Test fun switchingControllerModesClearsOldStereoObservations() {
|
||||
SpatialTracking.connect(0, 2, null, true, 1.6f, true)
|
||||
assertEquals(3, snapshot().getInt(32))
|
||||
SpatialTracking.setControllers(false, true)
|
||||
assertTrue(SpatialTracking.handsEnabled)
|
||||
assertEquals(5, snapshot().getInt(32))
|
||||
SpatialTracking.setControllers(true, false)
|
||||
assertEquals(3, snapshot().getInt(32))
|
||||
SpatialTracking.setControllers(false, false)
|
||||
assertFalse(SpatialTracking.handsEnabled)
|
||||
assertEquals(1, snapshot().getInt(32))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
import java.util.Locale
|
||||
|
||||
class SpatialMeasurementsTest {
|
||||
@Test fun validationKeepsExactImperialAndMetricMeasurements() {
|
||||
assertEquals(0.3048f, CalibrationDistance.INCHES_12.meters, 0.000001f)
|
||||
assertEquals(0.3f, CalibrationDistance.CENTIMETERS_30.meters, 0.000001f)
|
||||
assertEquals(0.508f, CalibrationDistance.INCHES_20.meters, 0.000001f)
|
||||
assertEquals(0.5f, CalibrationDistance.CENTIMETERS_50.meters, 0.000001f)
|
||||
}
|
||||
|
||||
@Test fun heightCarriesRoundedInchesIntoFeetAndAlwaysShowsBothUnits() {
|
||||
val previous = Locale.getDefault()
|
||||
try {
|
||||
Locale.setDefault(Locale.US)
|
||||
assertEquals("160 cm (5 ft 3.0 in)", SpatialMeasurements.height(160))
|
||||
assertEquals("183 cm (6 ft 0.0 in)", SpatialMeasurements.height(183))
|
||||
assertEquals("1.0 m (3.3 ft)", SpatialMeasurements.distance(1f))
|
||||
assertEquals("50.8 cm (20.00 in)", SpatialMeasurements.validation(0.508f))
|
||||
} finally { Locale.setDefault(previous) }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,310 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
import kotlin.math.sqrt
|
||||
|
||||
class SpatialPoseTest {
|
||||
private val t=1_000_000_000L
|
||||
private fun sample(x: Float=0f,y: Float=0f,z: Float=0f,time: Long=t,generation: Long=7,valid: Boolean=true,
|
||||
rotation: SpatialRotation=SpatialRotation())=SpatialSample(SpatialPose(SpatialVector(x,y,z),rotation),time,generation,valid)
|
||||
private fun session()=SpatialSession().apply { reset(7,1.6f);accept(sample()) }
|
||||
private fun near(expected: Float,actual: Float)=assertEquals(expected,actual,0.0001f)
|
||||
|
||||
@Test fun sdkPoseKeepsMetersAndCanonicalAxes() {
|
||||
val p=SpatialPose.fromSdk(floatArrayOf(1f,2f,-3f,1.1f,0f,0f,0f))!!
|
||||
assertEquals(SpatialVector(1f,2f,-3f),p.position);near(1f,p.rotation.w)
|
||||
assertNull(SpatialPose.fromSdk(floatArrayOf(0f,0f,0f,0f,0f,0f,0f)))
|
||||
assertNull(SpatialPose.fromSdk(floatArrayOf(Float.NaN,0f,0f,1f,0f,0f,0f)))
|
||||
}
|
||||
@Test fun quaternionRotationAndInverseAgree() {
|
||||
val q=SpatialRotation(y=sqrt(0.5f),w=sqrt(0.5f))
|
||||
val p=SpatialPose(SpatialVector(1f,2f,3f),q)
|
||||
val front=q.apply(SpatialVector(z=-1f));near(-1f,front.x);near(0f,front.z)
|
||||
val inverse=p.inverse()*p;near(0f,inverse.position.length());near(1f,inverse.rotation.w)
|
||||
}
|
||||
@Test fun floorSurvivesCrouchedRecenter() {
|
||||
val s=session();s.accept(sample(x=.2f,y=-.3f,time=t+10));s.recenter(false,t+10)
|
||||
near(1.3f,s.view(false)!!.position.y);near(0f,s.view(false)!!.position.x)
|
||||
s.accept(sample(x=.2f,time=t+20));near(1.6f,s.view(false)!!.position.y)
|
||||
}
|
||||
@Test fun screenAndVrOriginsStayIndependent() {
|
||||
val s=session();s.accept(sample(x=.2f,time=t+10));s.recenter(true,t+10)
|
||||
near(0f,s.view(true)!!.position.x);near(.2f,s.view(false)!!.position.x)
|
||||
s.accept(sample(x=.3f,time=t+20));s.recenter(false,t+20)
|
||||
near(.1f,s.view(true)!!.position.x);near(0f,s.view(false)!!.position.x)
|
||||
}
|
||||
@Test fun screenRecenterPreservesRecliningRotation() {
|
||||
val s=SpatialSession();s.reset(7,1.6f)
|
||||
val tilt=SpatialRotation(x=sqrt(.5f),w=sqrt(.5f))
|
||||
s.accept(sample(rotation=tilt));near(1f,s.view(true)!!.rotation.w)
|
||||
near(tilt.x,s.view(false)!!.rotation.x)
|
||||
}
|
||||
@Test fun staleHeadFreezesViewAndRejectsOldConnection() {
|
||||
val s=session();s.accept(sample(x=.1f,time=t+10));val last=s.view(false)
|
||||
assertFalse(s.accept(sample(x=99f,time=t+20,generation=6)))
|
||||
s.accept(sample(time=t+20,valid=false));assertEquals(last,s.view(false));assertFalse(s.valid(t+21))
|
||||
s.accept(sample(x=.1f,time=t+30));assertFalse(s.valid(t+100_000_031))
|
||||
assertFalse(s.accept(sample(x=Float.NaN,time=t+40)));assertEquals(last,s.view(false))
|
||||
}
|
||||
@Test fun discontinuityRequiresExplicitRecovery() {
|
||||
val s=session();assertFalse(s.accept(sample(x=5f,time=t+10)))
|
||||
assertTrue(s.needsRecenter);assertFalse(s.valid(t+10));near(0f,s.view(false)!!.position.x)
|
||||
s.recenter(false,t+10);assertTrue(s.recenterPending);assertFalse(s.valid(t+10))
|
||||
for (i in 1..6) s.accept(sample(x=5f,time=t+i*50_000_000L))
|
||||
assertTrue(s.valid(t+300_000_000));near(0f,s.view(false)!!.position.x)
|
||||
s.reset(8,1.6f,true);s.accept(sample(generation=8,time=t+400_000_000));assertFalse(s.valid(t+400_000_000))
|
||||
s.recenter(false,t+400_000_000)
|
||||
for (i in 1..6) s.accept(sample(generation=8,time=t+400_000_000+i*50_000_000L))
|
||||
assertTrue(s.valid(t+700_000_000))
|
||||
}
|
||||
@Test fun recenterDuringLostTrackingWaitsForSteadySamplesInsteadOfDroppingTheRequest() {
|
||||
val s=session();s.accept(sample(time=t+10,valid=false));val frozen=s.view(false)
|
||||
s.recenter(false,t+20);assertTrue(s.recenterPending)
|
||||
s.accept(sample(x=.2f,time=t+50_000_000))
|
||||
assertFalse(s.valid(t+50_000_000));assertEquals(frozen,s.view(false))
|
||||
for(i in 2..6) s.accept(sample(x=.2f,time=t+i*50_000_000L))
|
||||
assertFalse(s.recenterPending);assertTrue(s.valid(t+300_000_000));near(0f,s.view(false)!!.position.x)
|
||||
near(1.6f,s.view(false)!!.position.y)
|
||||
}
|
||||
@Test fun staleRecenterWaitsAndRepeatedTapsDoNotRestartTheWait() {
|
||||
val s=session();s.recenter(true,t+200_000_000);assertTrue(s.recenterPending)
|
||||
s.accept(sample(x=.2f,time=t+250_000_000))
|
||||
s.recenter(true,t+250_000_000)
|
||||
for(i in 1..5) s.accept(sample(x=.2f,time=t+250_000_000+i*50_000_000L))
|
||||
assertFalse(s.recenterPending);near(0f,s.view(true)!!.position.x)
|
||||
near(.2f,s.view(false)!!.position.x)
|
||||
}
|
||||
@Test fun unstableOrInterruptedRecoveryCannotAcceptANewOrigin() {
|
||||
val s=session();s.accept(sample(x=5f,time=t+10));s.recenter(false,t+10)
|
||||
for(i in 1..8) s.accept(sample(x=5f+(i%2)*.1f,time=t+i*50_000_000L))
|
||||
assertTrue(s.recenterPending);assertTrue(s.needsRecenter)
|
||||
s.accept(sample(x=5f,time=t+450_000_000))
|
||||
s.accept(sample(x=5f,time=t+500_000_000,valid=false))
|
||||
s.accept(sample(x=5f,time=t+550_000_000))
|
||||
assertTrue(s.recenterPending)
|
||||
for(i in 1..5) s.accept(sample(x=5f,time=t+550_000_000+i*50_000_000L))
|
||||
assertFalse(s.recenterPending);assertTrue(s.valid(t+800_000_000))
|
||||
}
|
||||
@Test fun disconnectCancelsQueuedRecenterAndOldSamplesCannotCompleteIt() {
|
||||
val s=session();s.recenter(false,t+200_000_000);assertTrue(s.recenterPending)
|
||||
s.reset(8,1.6f,true);assertFalse(s.recenterPending)
|
||||
for(i in 1..10) s.accept(sample(time=t+i*50_000_000L))
|
||||
assertTrue(s.needsRecenter);assertNull(s.latest())
|
||||
s.accept(sample(generation=8,time=t+600_000_000));assertFalse(s.valid(t+600_000_000))
|
||||
}
|
||||
@Test fun recoverableQuaternionScaleDoesNotCreateFalseDiscontinuities() {
|
||||
val s=session()
|
||||
for(i in 1..4) assertTrue(s.accept(sample(time=t+i,rotation=SpatialRotation(w=.8f))))
|
||||
assertFalse(s.needsRecenter);near(1f,s.latest()!!.pose.rotation.w)
|
||||
}
|
||||
@Test fun calibrationFrameChangesOnlyWhenTheTrackingFrameChanges() {
|
||||
val s=session();val frame=s.trackingFrameGeneration
|
||||
s.recenter(false,t);assertEquals(frame,s.trackingFrameGeneration)
|
||||
s.accept(sample(x=5f,time=t+10));assertEquals(frame+1,s.trackingFrameGeneration)
|
||||
s.accept(sample(x=5f,time=t+20));assertEquals(frame+1,s.trackingFrameGeneration)
|
||||
s.reset(8,1.6f,true);assertEquals(frame+2,s.trackingFrameGeneration)
|
||||
}
|
||||
@Test fun captureRemainsValidWhenHeadPollingAdvancesDuringBoardDetection() {
|
||||
val s=session();val frame=s.trackingFrameGeneration
|
||||
val detectionStarted=t+1_000_000L
|
||||
s.accept(sample(x=.01f,time=t+20_000_000L))
|
||||
assertFalse(s.valid(detectionStarted))
|
||||
assertTrue(s.isCurrentTrackingFrame(7,frame) { t+25_000_000L })
|
||||
}
|
||||
@Test fun captureCompletionStillRejectsStaleChangedAndDisconnectedTracking() {
|
||||
val s=session();val frame=s.trackingFrameGeneration
|
||||
assertFalse(s.isCurrentTrackingFrame(7,frame) { t+100_000_001L })
|
||||
s.accept(sample(x=5f,time=t+10));assertFalse(s.isCurrentTrackingFrame(7,frame) { t+20 })
|
||||
s.recenter(false,t+20)
|
||||
for(i in 1..6) s.accept(sample(x=5f,time=t+i*50_000_000L))
|
||||
assertTrue(s.valid(t+300_000_000L))
|
||||
assertFalse(s.isCurrentTrackingFrame(7,frame) { t+300_000_000L })
|
||||
s.reset(8,1.6f);s.accept(sample(generation=8,time=t+400_000_000L))
|
||||
assertFalse(s.isCurrentTrackingFrame(7,frame) { t+400_000_000L })
|
||||
}
|
||||
@Test fun newerHeadDoesNotRefreshOlderHand() {
|
||||
val s=session();s.setHands(7,SpatialHand(SpatialPose(),t,true,1f,true),SpatialHand())
|
||||
s.accept(sample(time=t+80_000_000))
|
||||
s.accept(sample(time=t+150_000_000));assertTrue(s.hand(0,t+200_000_000).valid)
|
||||
assertEquals(t,s.hand(0,t+200_000_000).timeNs)
|
||||
assertFalse(s.hand(0,t+200_000_001).valid)
|
||||
s.recenter(false,t+200_000_001);assertFalse(s.hand(0,t+200_000_001).valid)
|
||||
s.reset(8,1.6f);s.setHands(7,SpatialHand(timeNs=t,valid=true),SpatialHand());assertFalse(s.hand(0,t).valid)
|
||||
}
|
||||
private fun heldHand(time: Long = t) = SpatialHand(timeNs=time,valid=true,trigger=1f,grip=true)
|
||||
private fun epochs(session: SpatialSession) = List(4) { (session.inputEpochs() ushr (it*8)) and 0xff }
|
||||
@Test fun overwrittenHandLossRemainsVisibleAfterHeldGestureReturns() {
|
||||
val s=session();s.setHands(7,heldHand(),heldHand())
|
||||
s.setHands(7,SpatialHand(),heldHand(t+10))
|
||||
s.setHands(7,heldHand(t+20),heldHand(t+20))
|
||||
assertEquals(listOf(1,1,0,0),epochs(s))
|
||||
assertTrue(s.hand(0,t+20).valid);assertTrue(s.hand(0,t+20).grip)
|
||||
assertEquals(listOf(1,1,0,0),epochs(s))
|
||||
}
|
||||
@Test fun triggerAndGripLossEpochsAreIndependentForBothHands() {
|
||||
val s=session();s.setHands(7,heldHand(),heldHand())
|
||||
s.setHands(7,heldHand(t+10).copy(triggerValid=false),heldHand(t+10))
|
||||
assertEquals(listOf(1,0,0,0),epochs(s))
|
||||
assertTrue(s.hand(0,t+10).gripValid)
|
||||
s.setHands(7,heldHand(t+20).copy(gripValid=false),heldHand(t+20).copy(triggerValid=false))
|
||||
assertEquals(listOf(1,1,1,0),epochs(s))
|
||||
s.setHands(7,heldHand(t+30).copy(gripValid=false),heldHand(t+30).copy(triggerValid=false))
|
||||
assertEquals(listOf(1,1,1,0),epochs(s))
|
||||
assertFalse(s.hand(0,t+30).gripValid);assertTrue(s.hand(0,t+30).triggerValid)
|
||||
}
|
||||
@Test fun overwrittenHeadLossDoesNotLoseTheInputReset() {
|
||||
val s=session();s.setHands(7,heldHand(),heldHand())
|
||||
s.accept(sample(time=t+10,valid=false))
|
||||
s.accept(sample(time=t+20))
|
||||
s.setHands(7,heldHand(t+20),heldHand(t+20))
|
||||
assertEquals(listOf(1,1,1,1),epochs(s))
|
||||
assertTrue(s.hand(0,t+20).triggerValid)
|
||||
}
|
||||
@Test fun headGapClearsCachedHandsEvenWithoutAnInvalidSnapshot() {
|
||||
val s=session();s.setHands(7,heldHand(),heldHand())
|
||||
s.accept(sample(time=t+100_000_001))
|
||||
assertFalse(s.hand(0,t+100_000_001).valid)
|
||||
assertEquals(listOf(1,1,1,1),epochs(s))
|
||||
s.setHands(7,heldHand(t+110_000_000),heldHand(t+110_000_000))
|
||||
assertTrue(s.hand(0,t+110_000_000).valid)
|
||||
assertEquals(listOf(1,1,1,1),epochs(s))
|
||||
}
|
||||
@Test fun latePreLossCaptureCannotRearmAnInputAfterHeadRecovery() {
|
||||
val s=session();s.setHands(7,heldHand(),heldHand())
|
||||
s.accept(sample(time=t+20,valid=false));s.accept(sample(time=t+30))
|
||||
val released=heldHand(t+10).copy(trigger=0f,grip=false)
|
||||
s.setHands(7,released,released)
|
||||
val late=s.hand(0,t+30)
|
||||
assertTrue(late.valid);assertFalse(late.triggerValid);assertFalse(late.gripValid)
|
||||
assertEquals(listOf(1,1,1,1),epochs(s))
|
||||
s.setHands(7,released.copy(timeNs=t+40),released.copy(timeNs=t+40))
|
||||
assertTrue(s.hand(0,t+40).triggerValid);assertTrue(s.hand(0,t+40).gripValid)
|
||||
assertEquals(listOf(1,1,1,1),epochs(s))
|
||||
}
|
||||
@Test fun freshReplacementAfterLongHandGapStillAdvancesResetEpoch() {
|
||||
val s=session();s.setHands(7,heldHand(),heldHand())
|
||||
for(i in 1..5) s.accept(sample(time=t+i*50_000_000))
|
||||
s.setHands(7,heldHand(t+250_000_000),heldHand(t+250_000_000))
|
||||
assertTrue(s.hand(0,t+250_000_000).valid)
|
||||
assertEquals(listOf(1,1,1,1),epochs(s))
|
||||
}
|
||||
@Test fun handExpiryAndRepeatedInvalidPollsOnlyIncrementOnce() {
|
||||
val s=session();s.setHands(7,heldHand(),SpatialHand())
|
||||
for(i in 1..4) s.accept(sample(time=t+i*50_000_000))
|
||||
assertTrue(s.hand(0,t+200_000_000).valid)
|
||||
repeat(4) { assertFalse(s.hand(0,t+200_000_001+it).valid) }
|
||||
assertEquals(listOf(1,1,0,0),epochs(s))
|
||||
s.setHands(7,heldHand(t+210_000_000),SpatialHand())
|
||||
assertTrue(s.hand(0,t+210_000_000).valid)
|
||||
assertEquals(listOf(1,1,0,0),epochs(s))
|
||||
}
|
||||
@Test fun headExpiryThenDelayedHeadSampleDoesNotDoubleCountLoss() {
|
||||
val s=session();s.setHands(7,heldHand(),heldHand())
|
||||
for(i in 0..1) assertFalse(s.hand(i,t+100_000_001).valid)
|
||||
assertEquals(listOf(1,1,1,1),epochs(s))
|
||||
s.accept(sample(time=t+150_000_000))
|
||||
s.setHands(7,heldHand(t+160_000_000),heldHand(t+160_000_000))
|
||||
assertEquals(listOf(1,1,1,1),epochs(s))
|
||||
}
|
||||
@Test fun disabledHandsReleaseOnceAndWrongGenerationDoesNotAffectCurrentHands() {
|
||||
val s=session();s.setHands(7,heldHand(),heldHand())
|
||||
s.setHands(6,SpatialHand(),SpatialHand())
|
||||
assertTrue(s.hand(0,t).valid);assertEquals(listOf(0,0,0,0),epochs(s))
|
||||
repeat(3) { s.setHands(7,SpatialHand(),SpatialHand()) }
|
||||
assertEquals(listOf(1,1,1,1),epochs(s))
|
||||
s.reset(8,1.6f)
|
||||
assertEquals(0,s.inputEpochs())
|
||||
}
|
||||
@Test fun invalidTriggerValueOnlyInvalidatesItsOwnGestureEpoch() {
|
||||
val s=session();s.setHands(7,heldHand(),heldHand())
|
||||
s.setHands(7,heldHand(t+10).copy(trigger=Float.NaN),heldHand(t+10))
|
||||
assertEquals(listOf(1,0,0,0),epochs(s))
|
||||
assertFalse(s.hand(0,t+10).triggerValid);assertTrue(s.hand(0,t+10).gripValid)
|
||||
}
|
||||
@Test fun eachPackedEpochWrapsWithinItsOwnByte() {
|
||||
val s=session()
|
||||
repeat(255) {
|
||||
s.setHands(7,heldHand(t+it*2),heldHand(t+it*2))
|
||||
s.setHands(7,SpatialHand(),SpatialHand())
|
||||
}
|
||||
assertEquals(listOf(255,255,255,255),epochs(s));assertEquals(-1,s.inputEpochs())
|
||||
s.setHands(7,heldHand(t+512),heldHand(t+512));s.setHands(7,SpatialHand(),SpatialHand())
|
||||
assertEquals(0,s.inputEpochs())
|
||||
}
|
||||
@Test fun historyNeverCrossesReconnectOrLargeTimeGap() {
|
||||
val s=session();assertNotNull(s.poseAt(t+4_000_000,7));assertNull(s.poseAt(t+20_000_000,7))
|
||||
s.reset(8,1.6f);assertNull(s.poseAt(t,7))
|
||||
}
|
||||
@Test fun cameraClockWarmsUpAndRejectsResetAndJitter() {
|
||||
val clock=CameraClock();val offset=10_000_000_000L
|
||||
for(i in 1..15) assertNull(clock.map(i*40_000_000L,offset+i*40_000_000L))
|
||||
assertEquals(offset+640_000_000L,clock.map(640_000_000L,offset+640_000_000L))
|
||||
assertNull(clock.map(1,offset+1))
|
||||
val bad=CameraClock()
|
||||
for(i in 1..30) assertNull(bad.map(i*40_000_000L,offset+i*40_000_000L+(i%2)*30_000_000L))
|
||||
}
|
||||
@Test fun halfRateCameraClockRetainsSourceTimeThroughSkippedPairs() {
|
||||
val clock=CameraClock();val offset=10_000_000_000L
|
||||
for(i in 1..15) assertNull(clock.map(i*80_000_000L,offset+i*80_000_000L))
|
||||
assertEquals(offset+1_280_000_000L,clock.map(1_280_000_000L,offset+1_280_000_000L))
|
||||
assertEquals(offset+1_440_000_000L,clock.map(1_440_000_000L,offset+1_440_000_000L))
|
||||
assertNull(clock.map(1,offset+1))
|
||||
}
|
||||
@Test fun cameraClockKeepsAlignedMappingAfterLongSkippedGaps() {
|
||||
val offset=10_000_000_000L
|
||||
for(gap in listOf(240_000_000L,1_000_000_000L)) {
|
||||
val clock=CameraClock()
|
||||
for(i in 1..16) clock.map(i*80_000_000L,offset+i*80_000_000L)
|
||||
val source=1_280_000_000L+gap
|
||||
assertEquals(offset+source,clock.map(source,offset+source))
|
||||
assertEquals(offset+source+80_000_000L,clock.map(source+80_000_000L,offset+source+80_000_000L))
|
||||
}
|
||||
}
|
||||
@Test fun cameraClockRewarmsAfterSourceOrReceiptStopsOrReverses() {
|
||||
val offset=10_000_000_000L;val end=1_280_000_000L
|
||||
val resets=listOf(1L to offset+end+80_000_000L,
|
||||
end to offset+end+80_000_000L,
|
||||
end+80_000_000L to 1L,
|
||||
end+80_000_000L to offset+end)
|
||||
for((source,receipt) in resets) {
|
||||
val clock=CameraClock()
|
||||
for(i in 1..16) clock.map(i*80_000_000L,offset+i*80_000_000L)
|
||||
for(i in 0..14) assertNull(clock.map(source+i*80_000_000L,receipt+i*80_000_000L))
|
||||
assertEquals(receipt+1_200_000_000L,clock.map(source+1_200_000_000L,receipt+1_200_000_000L))
|
||||
}
|
||||
}
|
||||
@Test fun cameraClockRewarmsAfterOffsetJumpAcrossSkippedFrames() {
|
||||
val offset=10_000_000_000L
|
||||
for(gap in listOf(240_000_000L,1_000_000_000L)) for(jump in listOf(-20_000_001L,20_000_001L)) {
|
||||
val clock=CameraClock()
|
||||
for(i in 1..16) clock.map(i*80_000_000L,offset+i*80_000_000L)
|
||||
val source=1_280_000_000L+gap;val receipt=source+offset+jump
|
||||
for(i in 0..14) assertNull(clock.map(source+i*80_000_000L,receipt+i*80_000_000L))
|
||||
assertEquals(receipt+1_200_000_000L,clock.map(source+1_200_000_000L,receipt+1_200_000_000L))
|
||||
}
|
||||
}
|
||||
@Test fun cameraClockRetainsMappingWithBoundedJitterAcrossSkippedFrames() {
|
||||
val clock=CameraClock();val offset=10_000_000_000L
|
||||
for(i in 1..16) clock.map(i*80_000_000L,offset+i*80_000_000L+(i%2)*20_000_000L)
|
||||
assertEquals(offset+1_520_000_000L,clock.map(1_520_000_000L,offset+1_540_000_000L))
|
||||
assertEquals(offset+2_520_000_000L,clock.map(2_520_000_000L,offset+2_520_000_000L))
|
||||
assertNull(clock.map(2_760_000_000L,offset+2_780_000_001L))
|
||||
}
|
||||
@Test fun cameraClockRetainsMappingThroughIsolatedShortGapReceiptJitter() {
|
||||
val clock=CameraClock();val offset=10_000_000_000L
|
||||
for(i in 1..16) clock.map(i*80_000_000L,offset+i*80_000_000L)
|
||||
assertEquals(offset+1_360_000_000L,clock.map(1_360_000_000L,offset+1_390_000_000L))
|
||||
assertEquals(offset+1_440_000_000L,clock.map(1_440_000_000L,offset+1_440_000_000L))
|
||||
}
|
||||
@Test fun cameraClockInvalidTimestampRequiresFreshWarmup() {
|
||||
val offset=10_000_000_000L
|
||||
for((source,receipt) in listOf(0L to offset,-1L to offset,1L to 0L,1L to -1L)) {
|
||||
val clock=CameraClock()
|
||||
for(i in 1..16) clock.map(i*80_000_000L,offset+i*80_000_000L)
|
||||
assertNull(clock.map(source,receipt))
|
||||
for(i in 17..31) assertNull(clock.map(i*80_000_000L,offset+i*80_000_000L))
|
||||
assertEquals(offset+2_560_000_000L,clock.map(2_560_000_000L,offset+2_560_000_000L))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
|
||||
class SteamVrSpatialGateTest {
|
||||
@Test fun launchWaitsForRunningThenTheEntireSettleInterval() {
|
||||
val gate = SteamVrSpatialGate()
|
||||
assertTrue(gate.spatialEnabled(true, 0))
|
||||
gate.prepare()
|
||||
assertFalse(gate.spatialEnabled(true, 60_000))
|
||||
gate.setRunning(false, 60_000)
|
||||
assertFalse(gate.spatialEnabled(true, 60_000))
|
||||
gate.setRunning(true, 60_000)
|
||||
assertFalse(gate.spatialEnabled(true, 61_999))
|
||||
assertTrue(gate.spatialEnabled(true, 62_000))
|
||||
assertFalse(gate.spatialEnabled(false, 62_000))
|
||||
}
|
||||
|
||||
@Test fun repeatedRunningAndActivityPreparationDoNotMoveTheDeadline() {
|
||||
val gate = SteamVrSpatialGate()
|
||||
gate.prepare()
|
||||
gate.setRunning(true, 100)
|
||||
gate.prepare()
|
||||
gate.setRunning(true, 1_900)
|
||||
assertEquals(2_100L, gate.deadline)
|
||||
assertTrue(gate.spatialEnabled(true, 2_100))
|
||||
gate.prepare()
|
||||
gate.setRunning(true, 10_000)
|
||||
assertTrue(gate.spatialEnabled(true, 10_000))
|
||||
}
|
||||
|
||||
@Test fun explicitCancelRestoresSavedTrackingBeforeRunningAndDuringSettling() {
|
||||
val gate = SteamVrSpatialGate()
|
||||
gate.prepare()
|
||||
gate.cancel()
|
||||
assertTrue(gate.spatialEnabled(true, 100))
|
||||
assertFalse(gate.spatialEnabled(false, 100))
|
||||
gate.prepare()
|
||||
gate.setRunning(true, 200)
|
||||
gate.cancel()
|
||||
assertNull(gate.deadline)
|
||||
assertTrue(gate.spatialEnabled(true, 201))
|
||||
assertFalse(gate.spatialEnabled(false, 10_000))
|
||||
}
|
||||
|
||||
@Test fun stopAndNewLaunchCannotReuseAnEarlierDeadline() {
|
||||
val gate = SteamVrSpatialGate()
|
||||
gate.prepare()
|
||||
gate.setRunning(true, 100)
|
||||
gate.setRunning(false, 200)
|
||||
assertTrue(gate.spatialEnabled(true, 200))
|
||||
gate.prepare()
|
||||
assertFalse(gate.spatialEnabled(true, 2_100))
|
||||
gate.setRunning(false, 2_100)
|
||||
assertFalse(gate.spatialEnabled(true, 2_100))
|
||||
gate.setRunning(true, 3_000)
|
||||
assertFalse(gate.spatialEnabled(true, 4_999))
|
||||
assertTrue(gate.spatialEnabled(true, 5_000))
|
||||
}
|
||||
|
||||
@Test fun discoveringAnAlreadyRunningSessionStillAllowsSettling() {
|
||||
val gate = SteamVrSpatialGate()
|
||||
gate.setRunning(true, 100)
|
||||
assertFalse(gate.spatialEnabled(true, 2_099))
|
||||
assertTrue(gate.spatialEnabled(true, 2_100))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.json.JSONObject
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.RuntimeEnvironment
|
||||
import org.robolectric.annotation.Config
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [28])
|
||||
class StereoCalibrationProfileTest {
|
||||
private fun base() = RuntimeEnvironment.getApplication().assets.open(StereoCalibrationProfile.BASE_ASSET)
|
||||
.bufferedReader().use { it.readText() }
|
||||
private fun device(verified: Boolean = true) = JSONObject(base()).put("identity", "my-glasses")
|
||||
.put("verified", verified).toString()
|
||||
private fun select(saved: String? = null, identity: String? = "my-glasses", width: Int = 640, height: Int = 480) =
|
||||
StereoCalibrationProfile.select(saved, ::base, identity, width, height)
|
||||
|
||||
@Test fun newGlassesUseSharedGeometryWithoutClaimingIndividualValidation() {
|
||||
val profile = select()!!
|
||||
assertEquals("my-glasses", profile.identity)
|
||||
assertTrue(profile.bundledBase)
|
||||
assertFalse(profile.verified)
|
||||
assertEquals(1.1209395390660726, profile.error, 0.0)
|
||||
assertEquals(226.0499636040297, profile.matrices[0].values[0], 0.0)
|
||||
assertEquals(-0.05607918f, profile.cameraToHead.position.x, 0f)
|
||||
}
|
||||
|
||||
@Test fun unknownSerialCanUseTheModelBase() {
|
||||
val profile = select(identity = null)!!
|
||||
assertEquals(StereoCalibrationProfile.BASE_IDENTITY, profile.identity)
|
||||
assertTrue(profile.bundledBase)
|
||||
assertFalse(profile.verified)
|
||||
}
|
||||
|
||||
@Test fun savedDeviceProfileWinsWithoutReadingTheAsset() {
|
||||
val profile = StereoCalibrationProfile.select(device(), { error("Base must not be read") }, "my-glasses", 640, 480)!!
|
||||
assertFalse(profile.bundledBase)
|
||||
assertTrue(profile.verified)
|
||||
}
|
||||
|
||||
@Test fun unfinishedPersonalCalibrationStillRequiresDistanceValidation() {
|
||||
val profile = select(device(verified = false))!!
|
||||
assertFalse(profile.bundledBase)
|
||||
assertFalse(profile.verified)
|
||||
}
|
||||
|
||||
@Test fun foreignOrCorruptDeviceProfileFallsBackToBase() {
|
||||
assertTrue(select(JSONObject(device()).put("identity", "other-glasses").toString())!!.bundledBase)
|
||||
assertTrue(select("not json")!!.bundledBase)
|
||||
}
|
||||
|
||||
@Test fun otherCameraGeometryDoesNotUseTheBase() {
|
||||
assertNull(select(width = 1280, height = 960))
|
||||
assertNull(select(width = 480, height = 640))
|
||||
}
|
||||
|
||||
@Test fun baseRequiresTheCorrectModelAndCameraPair() {
|
||||
for ((key, value) in listOf("deviceModel" to "VITURE Luma Pro", "cameraPair" to "left1-right1", "identity" to "device-serial")) {
|
||||
val text = JSONObject(base()).put(key, value).toString()
|
||||
assertNull(StereoCalibrationProfile.select(null, { text }, "my-glasses", 640, 480))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun badLensDimensionsAndInvalidFitsAreRejectedBeforeNativeAllocation() {
|
||||
for (name in listOf("k1", "d1", "k2", "d2", "r", "t")) {
|
||||
val data = JSONObject(base())
|
||||
data.getJSONObject(name).put("rows", 2)
|
||||
assertNull(StereoCalibrationProfile.parse(data.toString(), StereoCalibrationProfile.BASE_IDENTITY, 640, 480, true))
|
||||
}
|
||||
for (error in listOf(-1.0, 2.01)) {
|
||||
val data = JSONObject(base()).put("error", error)
|
||||
assertNull(StereoCalibrationProfile.parse(data.toString(), StereoCalibrationProfile.BASE_IDENTITY, 640, 480, true))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun missingAssetAndNoDeviceProfileRequiresCalibration() {
|
||||
assertNull(StereoCalibrationProfile.select(null, { null }, "my-glasses", 640, 480))
|
||||
}
|
||||
|
||||
@Test fun shippedBaseContainsNoSourceSerialOrFalseValidationClaim() {
|
||||
val data = JSONObject(base())
|
||||
assertEquals(StereoCalibrationProfile.BASE_IDENTITY, data.getString("identity"))
|
||||
assertFalse(data.getBoolean("verified"))
|
||||
assertTrue(data.getJSONObject("sourceValidation").getBoolean("sourceDeviceVerified"))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
import kotlin.math.cos
|
||||
import kotlin.math.sin
|
||||
|
||||
class StereoFingerGesturesTest {
|
||||
private fun open(): MutableList<SpatialVector> {
|
||||
val p=MutableList(21) { SpatialVector(320f,240f) }
|
||||
p[4]=SpatialVector(390f,190f)
|
||||
for((base,x) in listOf(5 to 355f,9 to 330f,13 to 305f,17 to 280f)) {
|
||||
for(j in 0..3) p[base+j]=SpatialVector(x,180f-25f*j)
|
||||
}
|
||||
return p
|
||||
}
|
||||
private fun curl(p: MutableList<SpatialVector>,reach: Float=1f) = p.apply {
|
||||
for(base in listOf(9,13,17)) this[base+3]=this[0]+(this[base]-this[0])*reach
|
||||
}
|
||||
private fun transform(p: List<SpatialVector>,angle: Float,scale: Float,mirror: Boolean) = p.map {
|
||||
val x=(if(mirror) -it.x else it.x)*scale
|
||||
val y=it.y*scale
|
||||
SpatialVector(x*cos(angle)-y*sin(angle)+700f,x*sin(angle)+y*cos(angle)-80f)
|
||||
}
|
||||
@Test fun openingAndClosingAreIndependentOfImageScaleRotationAndHandedness() {
|
||||
for(mirror in listOf(false,true)) for(angle in listOf(0f,.7f,2.8f)) {
|
||||
val closed=curl(open()).apply { this[4]=this[8] }
|
||||
val result=StereoFingerGestures.estimate(transform(closed,angle,1.5f,mirror),
|
||||
transform(closed,angle+.12f,.7f,mirror),false)
|
||||
assertTrue(result.gripValid);assertTrue(result.grip)
|
||||
assertTrue(result.triggerValid);assertEquals(1f,result.trigger,0f)
|
||||
val released=StereoFingerGestures.estimate(transform(open(),angle,1.5f,mirror),
|
||||
transform(open(),angle+.12f,.7f,mirror),true)
|
||||
assertTrue(released.gripValid);assertFalse(released.grip)
|
||||
assertTrue(released.triggerValid);assertEquals(0f,released.trigger,0f)
|
||||
}
|
||||
}
|
||||
@Test fun curlThresholdsProvideObservedHysteresisAndRelease() {
|
||||
val partial=curl(open(),1.4f)
|
||||
val idle=StereoFingerGestures.estimate(partial,partial,false)
|
||||
val held=StereoFingerGestures.estimate(partial,partial,true)
|
||||
assertTrue(idle.gripValid);assertFalse(idle.grip)
|
||||
assertTrue(held.gripValid);assertTrue(held.grip)
|
||||
val opening=curl(open(),1.6f)
|
||||
assertFalse(StereoFingerGestures.estimate(opening,opening,true).grip)
|
||||
val two=curl(open()).apply { for(i in 17..20) this[i]=open()[i] }
|
||||
assertFalse(StereoFingerGestures.estimate(two,two,false).grip)
|
||||
assertTrue(StereoFingerGestures.estimate(two,two,true).grip)
|
||||
}
|
||||
@Test fun shortStraightProjectedFingersDoNotCountAsCurled() {
|
||||
val straight=open().apply {
|
||||
for(base in listOf(9,13,17)) for(j in 1..3) this[base+j]=this[base]+SpatialVector(y=-4.5f*j)
|
||||
}
|
||||
val result=StereoFingerGestures.estimate(straight,straight,false)
|
||||
assertTrue(result.gripValid);assertFalse(result.grip)
|
||||
}
|
||||
@Test fun pinchRequiresBothEyesAndUsesTheirMoreOpenEstimate() {
|
||||
fun pinch(ratio: Float)=open().apply { this[4]=this[8]+SpatialVector(x=75f*ratio) }
|
||||
val result=StereoFingerGestures.estimate(pinch(.25f),pinch(.30f),false)
|
||||
assertTrue(result.triggerValid);assertEquals((.55f-.30f)/.35f,result.trigger,.0001f)
|
||||
val conflict=StereoFingerGestures.estimate(pinch(.25f),pinch(.50f),false)
|
||||
assertFalse(conflict.triggerValid);assertEquals(0f,conflict.trigger,0f)
|
||||
assertTrue(conflict.gripValid);assertFalse(conflict.grip)
|
||||
}
|
||||
@Test fun conflictingCurlDoesNotReportAnObservedRelease() {
|
||||
val result=StereoFingerGestures.estimate(curl(open()),open(),true)
|
||||
assertFalse(result.gripValid);assertFalse(result.grip)
|
||||
assertTrue(result.triggerValid)
|
||||
}
|
||||
@Test fun invalidJointsOnlyInvalidateTheirOwnGesture() {
|
||||
val badPinch=open().apply { this[4]=SpatialVector(Float.NaN,190f) }
|
||||
val pinch=StereoFingerGestures.estimate(badPinch,open(),false)
|
||||
assertFalse(pinch.triggerValid);assertTrue(pinch.gripValid)
|
||||
val badGrip=open().apply { this[15]=SpatialVector(300f,Float.POSITIVE_INFINITY) }
|
||||
val grip=StereoFingerGestures.estimate(open(),badGrip,true)
|
||||
assertTrue(grip.triggerValid);assertFalse(grip.gripValid);assertFalse(grip.grip)
|
||||
}
|
||||
@Test fun missingViewsAndDegeneratePalmsCannotArmInputs() {
|
||||
val flat=open().apply { for(i in listOf(0,5,9,13,17)) this[i]=SpatialVector(i.toFloat(),0f) }
|
||||
val collapsed=open().apply { this[17]=this[5] }
|
||||
for(invalid in listOf(null,emptyList(),flat,collapsed)) {
|
||||
val result=StereoFingerGestures.estimate(open(),invalid,true)
|
||||
assertFalse(result.triggerValid);assertFalse(result.gripValid)
|
||||
assertEquals(0f,result.trigger,0f);assertFalse(result.grip)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import java.util.concurrent.CountDownLatch
|
||||
import java.util.concurrent.Executors
|
||||
import java.util.concurrent.TimeUnit
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
|
||||
class StereoInferenceRunnerTest {
|
||||
@Test fun camerasRunConcurrentlyAndRightDetectorKeepsItsOwnerThread() {
|
||||
StereoInferenceRunner().use { runner ->
|
||||
val owner=runner.onRight { Thread.currentThread() }
|
||||
val rightStarted=CountDownLatch(1)
|
||||
val leftStarted=CountDownLatch(1)
|
||||
val pair=runner.pair({
|
||||
leftStarted.countDown()
|
||||
assertTrue(rightStarted.await(2,TimeUnit.SECONDS))
|
||||
1
|
||||
}, {
|
||||
rightStarted.countDown()
|
||||
assertTrue(leftStarted.await(2,TimeUnit.SECONDS))
|
||||
assertSame(owner,Thread.currentThread())
|
||||
2
|
||||
})
|
||||
assertEquals(1 to 2,pair)
|
||||
assertSame(owner,runner.onRight { Thread.currentThread() })
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun leftFailureDoesNotReleasePixelsWhileRightStillUsesThem() {
|
||||
StereoInferenceRunner().use { runner ->
|
||||
val finished=CountDownLatch(1)
|
||||
val failure=IllegalStateException("left")
|
||||
try {
|
||||
runner.pair({ throw failure }, { Thread.sleep(25);finished.countDown();1 })
|
||||
fail("Expected inference failure")
|
||||
} catch(e: IllegalStateException) { assertSame(failure,e) }
|
||||
assertEquals(0L,finished.count)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun rightFailureReachesOwnerAndWorkerCanStillCloseDetector() {
|
||||
StereoInferenceRunner().use { runner ->
|
||||
val failure=IllegalStateException("right")
|
||||
try {
|
||||
runner.pair({ 1 }, { throw failure })
|
||||
fail("Expected inference failure")
|
||||
} catch(e: IllegalStateException) { assertSame(failure,e) }
|
||||
assertTrue(runner.onRight { true })
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun shutdownInterruptionWaitsForInferenceBeforeReturningBuffers() {
|
||||
StereoInferenceRunner().use { runner ->
|
||||
val owner=Executors.newSingleThreadExecutor()
|
||||
val running=CountDownLatch(1);val release=CountDownLatch(1)
|
||||
try {
|
||||
val result=owner.submit<Boolean> {
|
||||
Thread.currentThread().interrupt()
|
||||
assertEquals(1 to 2,runner.pair({ 1 }, {
|
||||
running.countDown();check(release.await(2,TimeUnit.SECONDS));2
|
||||
}))
|
||||
Thread.interrupted()
|
||||
}
|
||||
assertTrue(running.await(2,TimeUnit.SECONDS))
|
||||
assertFalse(result.isDone)
|
||||
release.countDown()
|
||||
assertTrue(result.get(2,TimeUnit.SECONDS))
|
||||
} finally { release.countDown();owner.shutdownNow() }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
|
||||
class StereoPointValidationTest {
|
||||
private val p1=doubleArrayOf(400.0,0.0,320.0,0.0, 0.0,400.0,240.0,0.0, 0.0,0.0,1.0,0.0)
|
||||
private val p2=p1.copyOf().apply { this[3]=-24.0 }
|
||||
private val point=doubleArrayOf(0.0,0.0,.5,1.0)
|
||||
private val left=doubleArrayOf(320.0,240.0)
|
||||
private val right=doubleArrayOf(272.0,240.0)
|
||||
@Test fun metricDepthAndReprojectionThresholdAreUnchanged() {
|
||||
val result=StereoPointValidation.reconstruct(point,left,right,p1,p2)!!
|
||||
assertEquals(.5f,result.z,0f)
|
||||
assertNotNull(StereoPointValidation.reconstruct(point,left,doubleArrayOf(275.0,240.0),p1,p2))
|
||||
assertNull(StereoPointValidation.reconstruct(point,left,doubleArrayOf(275.01,240.0),p1,p2))
|
||||
}
|
||||
@Test fun aRejectedLandmarkDoesNotRemoveItsValidNeighbors() {
|
||||
val observations=listOf(left,doubleArrayOf(Double.NaN,240.0),left)
|
||||
val points=observations.map { StereoPointValidation.reconstruct(point,it,right,p1,p2) }
|
||||
assertNotNull(points[0]);assertNull(points[1]);assertNotNull(points[2])
|
||||
}
|
||||
@Test fun invalidDepthAndProjectionNeverProduceValidPoints() {
|
||||
for(z in listOf(-.5,.149,1.501,Double.NaN,Double.POSITIVE_INFINITY))
|
||||
assertNull(StereoPointValidation.reconstruct(doubleArrayOf(0.0,0.0,z,1.0),left,right,p1,p2))
|
||||
assertNull(StereoPointValidation.reconstruct(point.copyOf().apply { this[3]=0.0 },left,right,p1,p2))
|
||||
assertNull(StereoPointValidation.reconstruct(point,left,right,p1,p2.copyOf().apply { this[10]=-1.0 }))
|
||||
assertNull(StereoPointValidation.reconstruct(point,left,right,p1,p2.copyOf().apply { this[0]=Double.NaN }))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
|
||||
class TrackingRecoveryTest {
|
||||
@Test fun periodicStatusRefreshDetectsExpiryWithoutAnotherPoseCallback() {
|
||||
val time=1_000_000_000L
|
||||
val session=SpatialTracking.session
|
||||
try {
|
||||
session.reset(91,1.6f)
|
||||
session.accept(SpatialSample(SpatialPose(),time,91,true))
|
||||
SpatialTracking.refreshStatus(time)
|
||||
assertTrue(SpatialTracking.status.value.headFresh)
|
||||
assertNull(TrackingRecovery.forSession(true,true,SpatialTracking.status.value))
|
||||
SpatialTracking.refreshStatus(time+100_000_001)
|
||||
assertFalse(SpatialTracking.status.value.headFresh)
|
||||
assertEquals(TrackingRecovery.LOST,TrackingRecovery.forSession(true,true,SpatialTracking.status.value))
|
||||
session.accept(SpatialSample(SpatialPose(),time+110_000_000,91,true))
|
||||
SpatialTracking.refreshStatus(time+110_000_000)
|
||||
assertNull(TrackingRecovery.forSession(true,true,SpatialTracking.status.value))
|
||||
} finally {
|
||||
session.reset(92,1.6f)
|
||||
SpatialTracking.refreshStatus(time+200_000_000)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun healthyAndNonSpatialSessionsNeverShowRecovery() {
|
||||
assertNull(TrackingRecovery.forSession(true,true,SpatialTrackingStatus(trackingValid=true,headFresh=true)))
|
||||
assertNull(TrackingRecovery.forSession(false,false,SpatialTrackingStatus()))
|
||||
assertEquals(TrackingRecovery.DISCONNECTED,TrackingRecovery.forSession(true,false,SpatialTrackingStatus(trackingValid=true)))
|
||||
}
|
||||
|
||||
@Test fun pendingRecenterStillRequiresLookingAroundUntilHeadTrackingReturns() {
|
||||
val pending=SpatialTrackingStatus(recenterPending=true,needsRecenter=true)
|
||||
assertEquals(TrackingRecovery.LOST,TrackingRecovery.forSession(true,true,pending))
|
||||
assertEquals(TrackingRecovery.STABILIZING,TrackingRecovery.forSession(true,true,pending.copy(headFresh=true)))
|
||||
assertNull(TrackingRecovery.forSession(true,true,pending.copy(headFresh=true,trackingValid=true,recenterPending=false,needsRecenter=false)))
|
||||
}
|
||||
|
||||
@Test fun newTrackingFrameExplainsTheRequiredRecenter() {
|
||||
val changed=SpatialTrackingStatus(needsRecenter=true,headFresh=true)
|
||||
assertEquals(TrackingRecovery.RECENTER,TrackingRecovery.forSession(true,true,changed))
|
||||
assertEquals(TrackingRecovery.LOST,TrackingRecovery.forSession(true,true,changed.copy(headFresh=false)))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
class UvcStreamHealthTest {
|
||||
private fun sample(frames: Long = 901, lastMs: Long = 30990, endMs: Long = 31000,
|
||||
maximumGapMs: Long = 34) = LongArray(14).apply {
|
||||
this[6]=lastMs*1_000_000
|
||||
this[7]=1_000_000_000
|
||||
this[8]=maximumGapMs*1_000_000
|
||||
this[9]=frames
|
||||
this[12]=endMs*1_000_000
|
||||
this[13]=(endMs-lastMs)*1_000_000
|
||||
}
|
||||
|
||||
@Test fun sustainedStreamMeasuresEntireWindow() {
|
||||
val health=UvcStreamHealth.assess(sample(),30,30000)
|
||||
assertTrue(health.healthy)
|
||||
assertEquals(30000.0,health.observationMs,0.001)
|
||||
assertEquals(30.0,health.observedFps,0.001)
|
||||
}
|
||||
|
||||
@Test fun earlyFramesCannotHideLongFinalStall() {
|
||||
val health=UvcStreamHealth.assess(sample(frames=31,lastMs=2000),30,30000)
|
||||
assertFalse(health.healthy)
|
||||
assertEquals(1.0,health.observedFps,0.001)
|
||||
assertEquals(29000.0,health.maximumGapMs,0.001)
|
||||
assertFalse(UvcStreamHealth.assess(sample(frames=1,lastMs=1000),30,30000).healthy)
|
||||
}
|
||||
|
||||
@Test fun frameRateCannotHideInterFrameOrFinalGaps() {
|
||||
assertFalse(UvcStreamHealth.assess(sample(maximumGapMs=500),30,30000).healthy)
|
||||
assertFalse(UvcStreamHealth.assess(sample(lastMs=30500),30,30000).healthy)
|
||||
}
|
||||
|
||||
@Test fun shortObservationAndLowFrameRateAreUnhealthy() {
|
||||
assertFalse(UvcStreamHealth.assess(sample(frames=31,lastMs=1990,endMs=2000),30,30000).healthy)
|
||||
assertFalse(UvcStreamHealth.assess(sample(frames=601),30,30000).healthy)
|
||||
assertFalse(UvcStreamHealth.assess(sample().apply { this[4]=-1 },30,30000).healthy)
|
||||
}
|
||||
|
||||
@Test fun lowFrameRateAllowsThreeFramePeriods() {
|
||||
assertTrue(UvcStreamHealth.assess(sample(frames=151,lastMs=30600,maximumGapMs=400),5,30000).healthy)
|
||||
assertFalse(UvcStreamHealth.assess(sample(frames=151,lastMs=30300,maximumGapMs=700),5,30000).healthy)
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,16 @@ import kotlin.math.sqrt
|
||||
import com.droiddeck.launcher.gpu.HeadPose
|
||||
|
||||
class VitureSdkTest {
|
||||
@Test fun spatialIdentityUsesTheFullSdkDigestAndRejectsMissingValues() {
|
||||
assertNull(VitureSpatialIdentity.fromSerialHash(null))
|
||||
assertNull(VitureSpatialIdentity.fromSerialHash(ByteArray(32)))
|
||||
assertNull(VitureSpatialIdentity.fromSerialHash(ByteArray(31) { 1 }))
|
||||
val digest=ByteArray(32) { it.toByte() }
|
||||
val id=VitureSpatialIdentity.fromSerialHash(digest)
|
||||
assertEquals("viture:sn-sha256:000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",id)
|
||||
assertEquals(id,VitureSpatialIdentity.fromSerialHash(digest.copyOf()))
|
||||
assertNotEquals(id,VitureSpatialIdentity.fromSerialHash(digest.copyOf().also { it[31]=0xff.toByte() }))
|
||||
}
|
||||
@Test fun pro2UsesItsOwnSdkTransportAndDisplayLimits() {
|
||||
val m = VitureProtocol.sdkModel("Pro 2")!!
|
||||
assertTrue(m.needsSdk)
|
||||
|
||||
@@ -33,6 +33,8 @@ class CardboardTest {
|
||||
val c = Cardboard(enabled = true, source = Cardboard.SOURCE_SBS, viewer = "none", ipdMm = 70,
|
||||
screenWidthDm = 55, screenDistanceDm = 25, headTracking = false)
|
||||
assertEquals(c, Cardboard.decode(c.encode()))
|
||||
val flat = c.copy(source = Cardboard.SOURCE_FLAT)
|
||||
assertEquals(flat, Cardboard.decode(flat.encode()))
|
||||
val wild = Cardboard.decode(JSONObject().put("ipdMm", 500).put("screenWidthDm", -3).put("viewer", "nope").put("source", 7))
|
||||
assertEquals(80, wild.ipdMm)
|
||||
assertEquals(5, wild.screenWidthDm)
|
||||
@@ -106,6 +108,18 @@ class CardboardTest {
|
||||
assertEquals(-cos(PI / 6).toFloat(), forward[2], eps)
|
||||
}
|
||||
|
||||
@Test fun virtualScreenRecenterUsesTheCurrentHeightAndDirection() {
|
||||
for (pitch in listOf(-30.0, -10.0, 15.0, 35.0)) {
|
||||
val yaw = matrix(quat(0f, 0f, 1f, 50.0))
|
||||
val tilt = HeadPose.multiply(matrix(quat(1f, 0f, 0f, pitch)), matrix(quat(0f, 0f, 1f, 12.0)))
|
||||
val screen = HeadPose.multiply(HeadPose.multiply(yaw, HeadPose.fromGlasses(0f, 0f, 0f, 1f)), tilt)
|
||||
val ref = HeadPose.recenter(screen, centerView = true)
|
||||
assertVec(HeadPose.IDENTITY, HeadPose.relative(ref, screen))
|
||||
val lookUp = matrix(quat(1f, 0f, 0f, 20.0))
|
||||
assertVec(lookUp, HeadPose.relative(ref, HeadPose.multiply(screen, lookUp)))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun turningTheHeadTurnsTheView() {
|
||||
val upright = floatArrayOf(1f, 0f, 0f, 0f, 0f, -1f, 0f, 1f, 0f)
|
||||
val ref = HeadPose.recenter(upright)
|
||||
|
||||
@@ -66,12 +66,13 @@ class JoyConShmTest {
|
||||
}
|
||||
|
||||
@Test fun reopeningKeepsTheSequenceMovingForward() {
|
||||
JoyConShm.open(file) {}!!.write(JoyCon.LEFT, JoyConShm.Hand(connected = true))
|
||||
val first = JoyConShm.open(file) {}!!
|
||||
first.write(JoyCon.LEFT, JoyConShm.Hand(connected = true))
|
||||
assertEquals(4, read().getInt(8))
|
||||
file.outputStream().use { }
|
||||
assertEquals(0L, file.length())
|
||||
first.close()
|
||||
val previous = read().getInt(8)
|
||||
assertNotNull(JoyConShm.open(file) {})
|
||||
assertEquals(2, read().getInt(8))
|
||||
assertTrue(read().getInt(8) > previous)
|
||||
java.io.RandomAccessFile(file, "rw").use { it.seek(8); it.write(byteArrayOf(7, 0, 0, 0)) }
|
||||
JoyConShm.open(file) {}!!
|
||||
val after = read().getInt(8)
|
||||
@@ -79,6 +80,14 @@ class JoyConShmTest {
|
||||
assertTrue("$after after a torn write", after > 7)
|
||||
}
|
||||
|
||||
@Test fun anEmptyFileStartsANewSequence() {
|
||||
file.parentFile!!.mkdirs()
|
||||
file.outputStream().use { }
|
||||
assertEquals(0L, file.length())
|
||||
assertNotNull(JoyConShm.open(file) {})
|
||||
assertEquals(2, read().getInt(8))
|
||||
}
|
||||
|
||||
@Test fun anUnwritableLocationIsReportedAsMissing() {
|
||||
val blocker = File(dir, "blocker").apply { writeText("") }
|
||||
assertNull(JoyConShm.open(File(blocker, JoyConShm.FILE)) {})
|
||||
|
||||
@@ -0,0 +1,130 @@
|
||||
package com.droiddeck.launcher.runtime
|
||||
|
||||
import android.content.ContextWrapper
|
||||
import com.droiddeck.launcher.session.SessionPhase
|
||||
import com.droiddeck.launcher.session.SessionState
|
||||
import java.io.File
|
||||
import java.nio.file.Files
|
||||
import org.junit.After
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.RuntimeEnvironment
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
class LinuxRuntimeLiveFilesTest {
|
||||
private val root = Files.createTempDirectory("guest-live-files").toFile()
|
||||
private val context = object : ContextWrapper(RuntimeEnvironment.getApplication()) {
|
||||
override fun getFilesDir() = File(root, "files").apply { mkdirs() }
|
||||
override fun getCacheDir() = File(root, "cache").apply { mkdirs() }
|
||||
override fun getNoBackupFilesDir() = File(root, "no_backup").apply { mkdirs() }
|
||||
}
|
||||
|
||||
@Before fun setUp() {
|
||||
SessionState.running = false
|
||||
SessionState.phase = SessionPhase.IDLE
|
||||
}
|
||||
|
||||
@After fun tearDown() {
|
||||
Thread.interrupted()
|
||||
SessionState.running = false
|
||||
SessionState.phase = SessionPhase.IDLE
|
||||
root.deleteRecursively()
|
||||
}
|
||||
|
||||
@Test fun cacheEvictionPreservesGuestSharedMemoryAndRuntimeBindings() {
|
||||
val binds = LinuxRuntime.binds(context, null, null, null, null)
|
||||
val shm = File(binds.single { it.endsWith(":/dev/shm") }.removeSuffix(":/dev/shm"))
|
||||
val live = LinuxRuntime.liveDir(context)
|
||||
val files = listOf(File(shm, "steamvr-ipc"), File(LinuxRuntime.prootTempDir(context), "loader"),
|
||||
File(live, "drm/device"), File(live, "bwrap/1/state"))
|
||||
files.forEach { it.parentFile!!.mkdirs(); it.writeText("active") }
|
||||
val disposable = File(context.cacheDir, "download").apply { writeText("cached") }
|
||||
|
||||
context.cacheDir.deleteRecursively()
|
||||
|
||||
assertFalse(disposable.exists())
|
||||
files.forEach { assertEquals("active", it.readText()) }
|
||||
assertTrue(live.path in binds)
|
||||
assertEquals(binds, LinuxRuntime.binds(context, null, null, null, null))
|
||||
assertTrue(live.toPath().startsWith(context.noBackupFilesDir.toPath()))
|
||||
}
|
||||
|
||||
@Test fun successfulRemovalClearsGuestScratchAndPreservesOtherNoBackupData() {
|
||||
val runtime = runtime()
|
||||
val scratch = scratch()
|
||||
val unrelated = File(context.noBackupFilesDir, "calibration.json").apply { writeText("preserved") }
|
||||
|
||||
assertTrue(LinuxRuntimeInstaller.beginUninstall(context, runtime)!!.run(null))
|
||||
|
||||
assertFalse(runtime.exists())
|
||||
assertFalse(scratch.exists())
|
||||
assertFalse(File(context.noBackupFilesDir, "guest-runtime").exists())
|
||||
assertEquals("preserved", unrelated.readText())
|
||||
}
|
||||
|
||||
@Test fun failedRuntimeRemovalPreservesGuestScratch() {
|
||||
val runtime = runtime()
|
||||
val scratch = scratch()
|
||||
val cannotMove = object : File(runtime.path) {
|
||||
override fun renameTo(dest: File) = false
|
||||
}
|
||||
|
||||
assertFalse(LinuxRuntimeInstaller.beginUninstall(context, cannotMove)!!.run(null))
|
||||
|
||||
assertTrue(runtime.exists())
|
||||
assertEquals("active", scratch.readText())
|
||||
}
|
||||
|
||||
@Test fun interruptedRemovalPreservesGuestScratch() {
|
||||
val runtime = runtime()
|
||||
val scratch = scratch()
|
||||
val removal = LinuxRuntimeInstaller.beginUninstall(context, runtime)!!
|
||||
|
||||
Thread.currentThread().interrupt()
|
||||
try {
|
||||
assertFalse(removal.run(null))
|
||||
} finally {
|
||||
Thread.interrupted()
|
||||
}
|
||||
|
||||
assertTrue(runtime.exists())
|
||||
assertEquals("active", scratch.readText())
|
||||
}
|
||||
|
||||
@Test fun aSessionStartingBeforeTheWorkerRunsPreservesRuntimeAndScratch() {
|
||||
val runtime = runtime()
|
||||
val scratch = scratch()
|
||||
val removal = LinuxRuntimeInstaller.beginUninstall(context, runtime)!!
|
||||
SessionState.phase = SessionPhase.STARTING_COMPOSITOR
|
||||
|
||||
assertFalse(removal.run(null))
|
||||
|
||||
assertTrue(runtime.exists())
|
||||
assertEquals("active", scratch.readText())
|
||||
}
|
||||
|
||||
@Test fun aSessionActiveBeforeScratchCleanupPreservesScratch() {
|
||||
val runtime = runtime()
|
||||
val scratch = scratch()
|
||||
val removal = LinuxRuntimeInstaller.beginUninstall(context, runtime)!!
|
||||
|
||||
assertFalse(removal.run { _, _ -> SessionState.running = true })
|
||||
|
||||
assertEquals("active", scratch.readText())
|
||||
}
|
||||
|
||||
private fun runtime() = LinuxRuntime.rootDir(context).apply {
|
||||
mkdirs()
|
||||
File(this, "runtime-file").writeText("installed")
|
||||
}
|
||||
|
||||
private fun scratch() = File(LinuxRuntime.liveDir(context), "shm/steamvr-ipc").apply {
|
||||
parentFile!!.mkdirs()
|
||||
writeText("active")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,171 @@
|
||||
package com.droiddeck.launcher.ui
|
||||
|
||||
import android.view.Display
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.rememberScrollState
|
||||
import androidx.compose.foundation.verticalScroll
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.runtime.*
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.focus.FocusRequester
|
||||
import androidx.compose.ui.focus.focusRequester
|
||||
import androidx.compose.ui.input.InputMode
|
||||
import androidx.compose.ui.input.InputModeManager
|
||||
import androidx.compose.ui.platform.LocalInputModeManager
|
||||
import androidx.compose.ui.input.key.Key
|
||||
import androidx.compose.ui.platform.LocalView
|
||||
import androidx.compose.ui.platform.testTag
|
||||
import androidx.compose.ui.test.*
|
||||
import androidx.compose.ui.unit.dp
|
||||
import com.droiddeck.launcher.glasses.GlassesResolution
|
||||
import com.droiddeck.launcher.glasses.GlassesSettings
|
||||
import com.droiddeck.launcher.glasses.GlassesState
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Rule
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.annotation.Config
|
||||
import org.robolectric.annotation.GraphicsMode
|
||||
import java.io.File
|
||||
|
||||
@OptIn(ExperimentalTestApi::class, androidx.compose.ui.ExperimentalComposeUiApi::class)
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [28], qualifiers = "w360dp-h800dp")
|
||||
@GraphicsMode(GraphicsMode.Mode.NATIVE)
|
||||
class GlassesMenuNavigationTest {
|
||||
@get:Rule val compose = createRobolectricComposeRule()
|
||||
private lateinit var view: android.view.View
|
||||
private lateinit var inputMode: InputModeManager
|
||||
private val firstTab = FocusRequester()
|
||||
private val glasses = GlassesState(present = true, connected = true, controllable = true,
|
||||
displayId = Display.DEFAULT_DISPLAY + 1, model = "VITURE Luma Ultra", width = 1920, height = 1200,
|
||||
hz = 60f, sbs90 = true, supportsSpatial = true, supportsScreen3dof = true, brightness = 4, volume = 3,
|
||||
resolutions = listOf(GlassesResolution(1920, 1080), GlassesResolution(1920, 1200)))
|
||||
|
||||
@Test fun narrowMenuSeparatesDisplayVrTrackingAndDevice() {
|
||||
show(inSession = false)
|
||||
compose.onNodeWithTag("setting-glasses-resolution-two_d").assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-resolution-three_d").assertExists()
|
||||
savePreview("display")
|
||||
compose.onNodeWithTag("glasses-distance").performScrollTo()
|
||||
savePreview("virtual-screen")
|
||||
compose.onNodeWithTag("glasses-tab-vr").assertIsDisplayed().performClick()
|
||||
compose.onNodeWithTag("setting-glasses-resolution-vr").assertIsDisplayed()
|
||||
compose.onNodeWithTag("setting-glasses-resolution-two_d").assertDoesNotExist()
|
||||
compose.onNodeWithTag("glasses-vr-fov").assertExists()
|
||||
savePreview("vr")
|
||||
compose.onNodeWithTag("glasses-tab-tracking").performClick()
|
||||
compose.onNodeWithText("LUMA ULTRA CAMERAS — EXPERIMENTAL").assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-position").assertExists()
|
||||
savePreview("tracking")
|
||||
compose.onNodeWithTag("setting-glasses-hands").performScrollTo().assertIsDisplayed()
|
||||
compose.onNodeWithTag("setting-glasses-joycons").assertExists()
|
||||
savePreview("hands")
|
||||
compose.onNodeWithTag("glasses-tab-hardware").assertIsDisplayed().performClick()
|
||||
compose.onNodeWithTag("glasses-brightness").assertIsDisplayed()
|
||||
compose.onNodeWithTag("glasses-volume").assertIsDisplayed()
|
||||
compose.onNodeWithTag("setting-glasses-sunblock").assertIsDisplayed()
|
||||
compose.onNodeWithTag("setting-glasses-position").assertDoesNotExist()
|
||||
savePreview("device")
|
||||
}
|
||||
|
||||
@Test fun controllerCanReachVrTabAndItsLaunchAction() {
|
||||
var launches = 0
|
||||
show(inSession = true, launch = { launches++ })
|
||||
compose.runOnIdle { inputMode.requestInputMode(InputMode.Keyboard); firstTab.requestFocus() }
|
||||
compose.onNodeWithTag("glasses-tab-display").assertIsFocused().performKeyInput {
|
||||
pressKey(Key.DirectionRight)
|
||||
pressKey(Key.Enter)
|
||||
}
|
||||
compose.onNodeWithTag("glasses-tab-vr").assertIsSelected()
|
||||
compose.onNodeWithTag("glasses-tab-vr").performKeyInput { pressKey(Key.DirectionDown) }
|
||||
compose.onNodeWithText("Start SteamVR").assertIsFocused().performKeyInput { pressKey(Key.Enter) }
|
||||
assertEquals(1, launches)
|
||||
savePreview("session-vr")
|
||||
}
|
||||
|
||||
@Test fun unavailableHardwareDoesNotLeaveEmptyTabs() {
|
||||
var tabs = emptyList<Pair<String, String>>()
|
||||
compose.setContent { DroidDeckTheme { tabs = glassesTabs(glasses.copy(connected = false)) } }
|
||||
compose.runOnIdle { assertEquals(listOf("display", "vr"), tabs.map { it.first }) }
|
||||
}
|
||||
|
||||
@Test fun threeDofRecenterComesFirstOnEveryTab() {
|
||||
assertRecenterComesFirst(GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN), false)
|
||||
}
|
||||
|
||||
@Test fun sixDofRecenterComesFirstOnEveryTab() {
|
||||
assertRecenterComesFirst(GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN, positionalTracking = true), false)
|
||||
}
|
||||
|
||||
@Test fun vrRecenterComesFirstOnEveryTab() {
|
||||
assertRecenterComesFirst(GlassesSettings(), true)
|
||||
}
|
||||
|
||||
private fun assertRecenterComesFirst(settings: GlassesSettings, vr: Boolean) {
|
||||
var recenters = 0
|
||||
show(inSession = true, settings = settings, steamVrRunning = vr, recenter = { recenters++ })
|
||||
val firstControls = listOf(
|
||||
GlassesTab.DISPLAY to "setting-glasses-game",
|
||||
GlassesTab.VR to "setting-glasses-auto3d",
|
||||
GlassesTab.TRACKING to "setting-glasses-tracking",
|
||||
GlassesTab.HARDWARE to "glasses-brightness",
|
||||
)
|
||||
for ((tab, control) in firstControls) {
|
||||
compose.onNodeWithTag("glasses-tab-$tab").performClick()
|
||||
val button = compose.onNodeWithText("Recenter").assertIsDisplayed()
|
||||
assertTrue("Recenter must precede $control", button.fetchSemanticsNode().boundsInRoot.bottom <=
|
||||
compose.onNodeWithTag(control).fetchSemanticsNode().boundsInRoot.top)
|
||||
button.performClick()
|
||||
}
|
||||
assertEquals(4, recenters)
|
||||
savePreview(if (vr) "recenter-vr" else if (settings.positionalTracking) "recenter-6dof" else "recenter-3dof")
|
||||
}
|
||||
|
||||
private fun show(inSession: Boolean, launch: () -> Unit = {},
|
||||
settings: GlassesSettings = GlassesSettings(positionalTracking = true),
|
||||
steamVrRunning: Boolean = false, recenter: (() -> Unit)? = null) {
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
view = LocalView.current
|
||||
inputMode = LocalInputModeManager.current
|
||||
var selected by remember { mutableStateOf(GlassesTab.DISPLAY) }
|
||||
val host = rememberMenuHost()
|
||||
Column(Modifier.fillMaxSize().background(MaterialTheme.colorScheme.background).padding(16.dp)) {
|
||||
SegmentedTabs(glassesTabs(glasses), selected, Modifier.fillMaxWidth(), tabModifier = { key ->
|
||||
Modifier.testTag("glasses-tab-$key").then(if (key == GlassesTab.DISPLAY)
|
||||
Modifier.focusRequester(firstTab) else Modifier)
|
||||
}) { selected = it; host.open = null }
|
||||
key(selected) {
|
||||
Column(Modifier.weight(1f).verticalScroll(rememberScrollState())) {
|
||||
CompositionLocalProvider(LocalChipMinWidth provides 120.dp) {
|
||||
GlassesGroups(host, glasses, settings, onRecenter = recenter, steamVrRunning = steamVrRunning,
|
||||
track = { if (it in listOf("glasses-width", "glasses-distance", "glasses-vr-fov",
|
||||
"glasses-brightness", "glasses-volume")) Modifier.testTag(it) else Modifier }, inSession = inSession, tab = selected,
|
||||
steamVr = { if (inSession) ActionRow("SteamVR", null, "Start SteamVR", launch) })
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun savePreview(name: String) {
|
||||
val file = File("build/reports/glasses-menus/$name.png")
|
||||
file.parentFile?.mkdirs()
|
||||
compose.runOnIdle {
|
||||
val root = view.rootView
|
||||
val bitmap = android.graphics.Bitmap.createBitmap(root.width, root.height, android.graphics.Bitmap.Config.ARGB_8888)
|
||||
root.draw(android.graphics.Canvas(bitmap))
|
||||
file.outputStream().use { bitmap.compress(android.graphics.Bitmap.CompressFormat.PNG, 100, it) }
|
||||
bitmap.recycle()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -6,9 +6,15 @@ import androidx.compose.foundation.rememberScrollState
|
||||
import androidx.compose.foundation.verticalScroll
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.platform.testTag
|
||||
import androidx.compose.ui.semantics.SemanticsProperties
|
||||
import androidx.compose.ui.test.SemanticsMatcher
|
||||
import androidx.compose.ui.test.assert
|
||||
import androidx.compose.ui.test.assertIsEnabled
|
||||
import androidx.compose.ui.test.assertIsNotEnabled
|
||||
import androidx.compose.ui.test.onNodeWithTag
|
||||
import androidx.compose.ui.test.onNodeWithText
|
||||
import androidx.compose.ui.test.performClick
|
||||
import androidx.compose.ui.test.performScrollTo
|
||||
import com.droiddeck.launcher.R
|
||||
import com.droiddeck.launcher.glasses.GlassesSettings
|
||||
import com.droiddeck.launcher.glasses.GlassesState
|
||||
@@ -24,6 +30,60 @@ import org.robolectric.annotation.Config
|
||||
class GlassesPanelTest {
|
||||
@get:Rule val compose = createRobolectricComposeRule()
|
||||
|
||||
@Test fun flatResolutionMenuShowsPerEyeResolutionsBesideRefresh() {
|
||||
show()
|
||||
compose.onNodeWithTag("setting-glasses-hz").assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-resolution-two_d").performScrollTo().performClick()
|
||||
compose.onNodeWithText("1920 × 1080").assertExists()
|
||||
compose.onNodeWithText("1920 × 1200").assertExists()
|
||||
}
|
||||
|
||||
@Test fun stereoResolutionHasItsOwnPreference() {
|
||||
show(stereo = true)
|
||||
compose.onNodeWithTag("setting-glasses-resolution-three_d").assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-resolution-two_d").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-3d-hz").assertExists()
|
||||
}
|
||||
|
||||
@Test fun vrResolutionDoesNotEditTheOrdinaryStereoPreference() {
|
||||
show(stereo = true, steamVrRunning = true, tab = GlassesTab.VR)
|
||||
compose.onNodeWithTag("setting-glasses-resolution-vr").performScrollTo().performClick()
|
||||
compose.onNodeWithText("1920 × 1080").assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-resolution-three_d").assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun homeDisplayCanConfigureBothOrdinaryResolutionProfiles() {
|
||||
show(inSession = false)
|
||||
for (profile in listOf("two_d", "three_d"))
|
||||
compose.onNodeWithTag("setting-glasses-resolution-$profile").assertExists()
|
||||
}
|
||||
|
||||
@Test fun nativeThirtyHzAppearsInTheFlatRefreshMenu() {
|
||||
show(supports30Hz = true)
|
||||
compose.onNodeWithTag("setting-glasses-hz").performScrollTo().performClick()
|
||||
compose.onNodeWithText("30 Hz").assertExists()
|
||||
}
|
||||
|
||||
@Test fun nativeThirtyHzAppearsInStereoEvenWithoutNinetyHzSupport() {
|
||||
show(stereo = true, supports30Hz = true, sbs90 = false)
|
||||
compose.onNodeWithTag("setting-glasses-3d-hz").performScrollTo().performClick()
|
||||
compose.onNodeWithText("30 Hz").assertExists()
|
||||
compose.onNodeWithText("90 Hz").assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun unsupportedThirtyHzIsAbsentFromTheRefreshMenu() {
|
||||
show()
|
||||
compose.onNodeWithTag("setting-glasses-hz").performScrollTo().performClick()
|
||||
compose.onNodeWithText("30 Hz").assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun mirroredNativeThirtyHzExplainsTheDedicatedOutputRequirement() {
|
||||
show(settings = GlassesSettings(gameOnGlasses = false), supports30Hz = true)
|
||||
compose.onNodeWithText(text(R.string.glasses_refresh_30_hint)).assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-hz").performScrollTo().performClick()
|
||||
compose.onNodeWithText("30 Hz").assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun automaticFlatGameOffersVirtualScreenInsteadOfIneffectiveSliders() {
|
||||
show()
|
||||
compose.onNodeWithTag("glasses-width").assertDoesNotExist()
|
||||
@@ -44,13 +104,13 @@ class GlassesPanelTest {
|
||||
}
|
||||
|
||||
@Test fun automaticSteamVrShowsFieldOfViewAndStereoRefresh() {
|
||||
show(stereo = true, steamVrRunning = true)
|
||||
show(stereo = true, steamVrRunning = true, tab = GlassesTab.VR)
|
||||
compose.onNodeWithTag("glasses-width").assertDoesNotExist()
|
||||
compose.onNodeWithTag("glasses-distance").assertDoesNotExist()
|
||||
compose.onNodeWithTag("glasses-vr-fov").assertIsEnabled()
|
||||
compose.onNodeWithTag("setting-glasses-hz").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-3d-hz").assertExists()
|
||||
compose.onNodeWithText(text(R.string.glasses_screen_direct_hint)).assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-auto3d").assertExists()
|
||||
}
|
||||
|
||||
@Test fun mirroredSteamVrIn2dKeepsFieldOfViewAndRecenter() {
|
||||
@@ -63,13 +123,22 @@ class GlassesPanelTest {
|
||||
assertMirroredVrControls()
|
||||
}
|
||||
|
||||
@Test fun mirroredSteamVrVirtualScreenKeepsGeometryAndRecenter() {
|
||||
@Test fun mirroredSteamVrUsesStereoControlsWithASavedVirtualScreen() {
|
||||
show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN),
|
||||
steamVrRunning = true, outputActive = false, tab = null)
|
||||
compose.onNodeWithTag("glasses-width").assertIsEnabled()
|
||||
compose.onNodeWithTag("glasses-distance").assertIsEnabled()
|
||||
compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertExists()
|
||||
compose.onNodeWithText(text(R.string.glasses_screen_no_output)).assertDoesNotExist()
|
||||
compose.onNodeWithTag("glasses-width").assertDoesNotExist()
|
||||
compose.onNodeWithTag("glasses-distance").assertDoesNotExist()
|
||||
compose.onNodeWithText(text(R.string.glasses_screen_direct_hint)).assertExists()
|
||||
assertMirroredVrControls()
|
||||
}
|
||||
|
||||
@Test fun automatic3dForVrUsesStereoControlsWithASavedVirtualScreen() {
|
||||
show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN, auto3d = true),
|
||||
stereo = true, steamVrRunning = true, tab = null)
|
||||
compose.onNodeWithTag("glasses-width").assertDoesNotExist()
|
||||
compose.onNodeWithTag("glasses-distance").assertDoesNotExist()
|
||||
compose.onNodeWithText(text(R.string.glasses_screen_direct_hint)).assertExists()
|
||||
assertMirroredVrControls()
|
||||
}
|
||||
|
||||
private fun assertMirroredVrControls() {
|
||||
@@ -78,13 +147,44 @@ class GlassesPanelTest {
|
||||
compose.onNodeWithText(text(R.string.glasses_screen_no_output)).assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun automaticStereoOutputWithoutSteamVrUsesVirtualScreenDimensions() {
|
||||
@Test fun automaticStereoOutputDoesNotEnable3dofOrVirtualScreenDimensions() {
|
||||
show(stereo = true)
|
||||
compose.onNodeWithTag("glasses-width").assertIsEnabled()
|
||||
compose.onNodeWithTag("glasses-distance").assertIsEnabled()
|
||||
compose.onNodeWithTag("setting-glasses-3dof").assert(
|
||||
SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off)))
|
||||
compose.onNodeWithTag("glasses-width").assertDoesNotExist()
|
||||
compose.onNodeWithTag("glasses-distance").assertDoesNotExist()
|
||||
compose.onNodeWithTag("glasses-vr-fov").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-hz").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-3d-hz").assertExists()
|
||||
compose.onNodeWithText(text(R.string.glasses_screen_flat_hint)).assertExists()
|
||||
compose.onNodeWithText(text(R.string.glasses_screen_sbs_hint)).assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun automaticFlatSbsKeepsTrackingInactive() {
|
||||
show(stereo = true, tab = GlassesTab.TRACKING)
|
||||
compose.onNodeWithText(text(R.string.glasses_tracking_flat_hint)).assertExists()
|
||||
compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun flatGame3dofToggleIsIndependentOfSbsAndShowsScreenControls() {
|
||||
show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN))
|
||||
compose.onNodeWithTag("setting-glasses-3dof").assert(
|
||||
SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_on)))
|
||||
compose.onNodeWithTag("setting-glasses-3d").assert(
|
||||
SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off)))
|
||||
compose.onNodeWithTag("glasses-width").assertIsEnabled()
|
||||
compose.onNodeWithTag("glasses-distance").assertIsEnabled()
|
||||
}
|
||||
|
||||
@Test fun separate3dofToggleIsHiddenWithoutHeadTrackingSupport() {
|
||||
show(supportsScreen3dof = false)
|
||||
compose.onNodeWithTag("setting-glasses-3dof").assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun virtualScreenRecenterExplainsHowToSetTheHeight() {
|
||||
show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN), tab = GlassesTab.TRACKING)
|
||||
compose.onNodeWithText(text(R.string.glasses_recenter_screen_hint)).assertExists()
|
||||
compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertExists()
|
||||
}
|
||||
|
||||
@Test fun gameWithoutGlassesOutputExplainsWhyGeometryIsUnavailable() {
|
||||
@@ -99,8 +199,8 @@ class GlassesPanelTest {
|
||||
show(inSession = false, outputActive = false)
|
||||
compose.onNodeWithTag("glasses-width").assertIsEnabled()
|
||||
compose.onNodeWithTag("glasses-distance").assertIsEnabled()
|
||||
compose.onNodeWithTag("glasses-vr-fov").assertIsEnabled()
|
||||
compose.onNodeWithText(text(R.string.glasses_screen_next_session)).assertExists()
|
||||
compose.onNodeWithTag("glasses-vr-fov").assertDoesNotExist()
|
||||
compose.onNodeWithText(text(R.string.glasses_screen_app_wide)).assertExists()
|
||||
}
|
||||
|
||||
@Test fun flatTrackingExplainsTheModeAndHidesInactiveRecenter() {
|
||||
@@ -116,12 +216,13 @@ class GlassesPanelTest {
|
||||
compose.onNodeWithTag("glasses-distance").assertIsEnabled()
|
||||
compose.onNodeWithTag("setting-glasses-hz").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-3d").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-3dof").assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun runningSteamVrFieldOfViewRemainsAvailableWhenUsbControlDisconnects() {
|
||||
show(stereo = true, steamVrRunning = true, controlAvailable = false)
|
||||
show(stereo = true, steamVrRunning = true, controlAvailable = false, tab = GlassesTab.VR)
|
||||
compose.onNodeWithTag("glasses-vr-fov").assertIsEnabled()
|
||||
compose.onNodeWithTag("setting-glasses-picture").assertIsEnabled()
|
||||
compose.onNodeWithTag("setting-glasses-picture").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-3d-hz").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-3d").assertDoesNotExist()
|
||||
}
|
||||
@@ -142,6 +243,152 @@ class GlassesPanelTest {
|
||||
compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun homeVrCanConfigureResolutionAndFieldOfViewBeforeLaunching() {
|
||||
show(inSession = false, tab = GlassesTab.VR)
|
||||
compose.onNodeWithTag("setting-glasses-resolution-vr").assertExists()
|
||||
compose.onNodeWithTag("glasses-vr-fov").assertIsEnabled()
|
||||
compose.onNodeWithTag("setting-glasses-auto3d").assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-picture").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-resolution-two_d").assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun displayKeepsVrAndHardwareControlsInTheirOwnTabs() {
|
||||
show(inSession = false)
|
||||
compose.onNodeWithTag("setting-glasses-auto3d").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-resolution-vr").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-sunblock").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-tracking").assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun recenterIsHiddenWhenHeadTrackingIsOff() {
|
||||
show(settings = GlassesSettings(headTracking = false, picture3d = GlassesSettings.PICTURE_SCREEN))
|
||||
compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun trackedMenusCanRecenterWithoutStartingASession() {
|
||||
var recenters = 0
|
||||
show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN), inSession = false,
|
||||
onRecenter = { recenters++ })
|
||||
|
||||
compose.onNodeWithText(text(R.string.glasses_recenter_screen_hint)).assertExists()
|
||||
compose.onNodeWithText(text(R.string.cardboard_recenter_button)).performClick()
|
||||
org.junit.Assert.assertEquals(1, recenters)
|
||||
}
|
||||
|
||||
@Test fun positionalMenusUseTheSameRecenterAction() {
|
||||
var recenters = 0
|
||||
show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN, positionalTracking = true),
|
||||
supportsSpatial = true, inSession = false, onRecenter = { recenters++ })
|
||||
|
||||
compose.onNodeWithText(text(R.string.glasses_recenter_screen_hint)).assertExists()
|
||||
compose.onNodeWithText(text(R.string.cardboard_recenter_button)).performClick()
|
||||
org.junit.Assert.assertEquals(1, recenters)
|
||||
}
|
||||
|
||||
@Test fun menusWithoutDedicatedGlassesOutputDoNotOfferRecenter() {
|
||||
show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN, gameOnGlasses = false),
|
||||
inSession = false)
|
||||
compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun spatialSteamVrIncludesHeadTrackingAndRestoresTheSavedVirtualScreenSwitch() {
|
||||
val vrRunning = androidx.compose.runtime.mutableStateOf(true)
|
||||
val saved = GlassesSettings(headTracking = false, positionalTracking = true,
|
||||
picture3d = GlassesSettings.PICTURE_SCREEN)
|
||||
show(settings = saved, supportsSpatial = true, tab = GlassesTab.TRACKING, observedSteamVr = vrRunning)
|
||||
|
||||
compose.onNodeWithTag("setting-glasses-tracking").assertIsNotEnabled().assert(
|
||||
SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_on)))
|
||||
compose.onNodeWithText(text(R.string.glasses_head_tracking_spatial_vr_hint)).assertExists()
|
||||
compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist()
|
||||
|
||||
compose.runOnIdle { vrRunning.value = false }
|
||||
|
||||
compose.onNodeWithTag("setting-glasses-tracking").assertIsEnabled().assert(
|
||||
SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off)))
|
||||
compose.onNodeWithText(text(R.string.glasses_head_tracking_spatial_hint)).assertExists()
|
||||
compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun rotationOnlySteamVrKeepsTheHeadTrackingSwitchOptional() {
|
||||
show(settings = GlassesSettings(headTracking = false), supportsSpatial = true,
|
||||
steamVrRunning = true, tab = GlassesTab.TRACKING)
|
||||
|
||||
compose.onNodeWithTag("setting-glasses-tracking").assertIsEnabled().assert(
|
||||
SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off)))
|
||||
compose.onNodeWithText(text(R.string.glasses_head_tracking_hint)).assertExists()
|
||||
compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun spatialPreferencesDoNotClaimHeadTrackingForPhoneOutput() {
|
||||
val noDisplay = androidx.compose.runtime.mutableStateOf(GlassesState(present = true,
|
||||
connected = true, controllable = true, supportsSpatial = true))
|
||||
show(settings = GlassesSettings(headTracking = false, positionalTracking = true),
|
||||
steamVrRunning = true, outputActive = false, tab = GlassesTab.TRACKING, observedState = noDisplay)
|
||||
|
||||
compose.onNodeWithTag("setting-glasses-tracking").assertIsEnabled().assert(
|
||||
SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off)))
|
||||
compose.onNodeWithText(text(R.string.glasses_screen_no_output)).assertExists()
|
||||
compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun experimentalJoyConsAreOffAndRequirePositionalTracking() {
|
||||
show(supportsSpatial = true, tab = GlassesTab.TRACKING)
|
||||
compose.onNodeWithText(text(R.string.glasses_experimental).uppercase()).assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-joycons").assertIsNotEnabled().assert(
|
||||
SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off)))
|
||||
}
|
||||
|
||||
@Test fun experimentalGroupFollowsOrdinaryTrackingAndEnablesJoyCons() {
|
||||
show(supportsSpatial = true, settings = GlassesSettings(positionalTracking = true), tab = GlassesTab.TRACKING)
|
||||
compose.onNodeWithTag("setting-glasses-joycons").performScrollTo().assertIsEnabled()
|
||||
val ordinary = compose.onNodeWithTag("setting-glasses-tracking").fetchSemanticsNode().positionInRoot.y
|
||||
val experimental = compose.onNodeWithText(text(R.string.glasses_experimental).uppercase()).fetchSemanticsNode().positionInRoot.y
|
||||
org.junit.Assert.assertTrue(experimental > ordinary)
|
||||
compose.onNodeWithTag("setting-glasses-hands").assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-steady-hand-aim").assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun steadyHandAimIsOptionalAndOffByDefault() {
|
||||
show(supportsSpatial = true, settings = GlassesSettings(positionalTracking = true, handControllers = true),
|
||||
tab = GlassesTab.TRACKING)
|
||||
compose.onNodeWithTag("setting-glasses-steady-hand-aim").performScrollTo().assertIsEnabled().assert(
|
||||
SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off)))
|
||||
compose.onNodeWithText(text(R.string.glasses_steady_hand_aim_hint)).assertExists()
|
||||
}
|
||||
|
||||
@Test fun savedSteadyHandAimIsHiddenInJoyConMode() {
|
||||
show(supportsSpatial = true, settings = GlassesSettings(positionalTracking = true, joyConTracking = true, steadyHandAim = true),
|
||||
tab = GlassesTab.TRACKING)
|
||||
compose.onNodeWithTag("setting-glasses-steady-hand-aim").assertDoesNotExist()
|
||||
}
|
||||
|
||||
@Test fun ultraControlsDisappearOnDisconnectAndForOtherGlassesWithSavedPreferences() {
|
||||
val state = androidx.compose.runtime.mutableStateOf(GlassesState(present = true, connected = true,
|
||||
controllable = true, supportsSpatial = true, model = "VITURE Luma Ultra"))
|
||||
show(settings = GlassesSettings(positionalTracking = true, handControllers = true, joyConTracking = true),
|
||||
tab = GlassesTab.TRACKING, observedState = state)
|
||||
compose.onNodeWithTag("setting-glasses-position").assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-hands").assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-joycons").assertExists()
|
||||
val otherStates = listOf(state.value.copy(connected = false)) +
|
||||
listOf("VITURE Luma Ultra", "VITURE Luma Pro", "VITURE Pro", "XREAL", "RayNeo").map {
|
||||
state.value.copy(model = it, supportsSpatial = false)
|
||||
}
|
||||
for (other in otherStates) {
|
||||
compose.runOnIdle { state.value = other }
|
||||
compose.onNodeWithTag("setting-glasses-position").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-hands").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-steady-hand-aim").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-glasses-joycons").assertDoesNotExist()
|
||||
compose.onNodeWithText(text(R.string.glasses_spatial_setup)).assertDoesNotExist()
|
||||
compose.onNodeWithText(text(R.string.glasses_eye_height)).assertDoesNotExist()
|
||||
compose.onNodeWithText(text(R.string.glasses_floor)).assertDoesNotExist()
|
||||
}
|
||||
compose.runOnIdle { state.value = state.value.copy(supportsSpatial = true) }
|
||||
compose.onNodeWithTag("setting-glasses-position").assertExists()
|
||||
}
|
||||
|
||||
private fun show(
|
||||
settings: GlassesSettings = GlassesSettings(),
|
||||
stereo: Boolean = false,
|
||||
@@ -149,23 +396,33 @@ class GlassesPanelTest {
|
||||
inSession: Boolean = true,
|
||||
outputActive: Boolean = inSession,
|
||||
controlAvailable: Boolean = true,
|
||||
supportsScreen3dof: Boolean = true,
|
||||
supportsSpatial: Boolean = false,
|
||||
supports30Hz: Boolean = false,
|
||||
sbs90: Boolean = true,
|
||||
tab: String? = GlassesTab.DISPLAY,
|
||||
observedState: androidx.compose.runtime.State<GlassesState>? = null,
|
||||
observedSteamVr: androidx.compose.runtime.State<Boolean>? = null,
|
||||
onRecenter: (() -> Unit)? = {},
|
||||
) {
|
||||
val state = GlassesState(present = true, connected = controlAvailable, controllable = true,
|
||||
displayId = Display.DEFAULT_DISPLAY + 1, width = if (stereo) 3840 else 1920, height = 1200,
|
||||
model = "VITURE Luma Ultra", sbs = stereo, sbs90 = true)
|
||||
model = "VITURE Luma Ultra", sbs = stereo, sbs90 = sbs90, supportsScreen3dof = supportsScreen3dof,
|
||||
supports30Hz = supports30Hz, supportsSpatial = supportsSpatial, resolutions = listOf(
|
||||
com.droiddeck.launcher.glasses.GlassesResolution(1920, 1080),
|
||||
com.droiddeck.launcher.glasses.GlassesResolution(1920, 1200)))
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
Column(Modifier.verticalScroll(rememberScrollState())) {
|
||||
GlassesGroups(rememberMenuHost(), state, settings,
|
||||
GlassesGroups(rememberMenuHost(), observedState?.value ?: state, settings,
|
||||
track = { key ->
|
||||
when (key) {
|
||||
"glasses-width", "glasses-distance", "glasses-vr-fov" -> Modifier.testTag(key)
|
||||
else -> Modifier
|
||||
}
|
||||
}, onRecenter = {},
|
||||
}, onRecenter = onRecenter,
|
||||
inSession = inSession, outputActive = outputActive,
|
||||
steamVrRunning = steamVrRunning, tab = tab)
|
||||
steamVrRunning = observedSteamVr?.value ?: steamVrRunning, tab = tab)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,160 @@
|
||||
package com.droiddeck.launcher.ui
|
||||
|
||||
import android.app.Application
|
||||
import android.content.Context
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import androidx.compose.runtime.CompositionLocalProvider
|
||||
import androidx.compose.ui.semantics.SemanticsProperties
|
||||
import androidx.compose.ui.test.SemanticsMatcher
|
||||
import androidx.compose.ui.test.assert
|
||||
import androidx.compose.ui.test.onNodeWithTag
|
||||
import androidx.compose.ui.test.onNodeWithText
|
||||
import androidx.compose.ui.test.performClick
|
||||
import androidx.compose.ui.test.performScrollTo
|
||||
import com.droiddeck.launcher.R
|
||||
import com.droiddeck.launcher.glasses.Glasses
|
||||
import com.droiddeck.launcher.glasses.GlassesSettings
|
||||
import com.droiddeck.launcher.glasses.GlassesState
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import org.junit.After
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Before
|
||||
import org.junit.Rule
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.RuntimeEnvironment
|
||||
import org.robolectric.Shadows.shadowOf
|
||||
import org.robolectric.annotation.Config
|
||||
import org.robolectric.annotation.LooperMode
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [28], qualifiers = "w1200dp-h752dp-land", application = Application::class)
|
||||
@LooperMode(LooperMode.Mode.PAUSED)
|
||||
class GlobalGlassesSettingsTest {
|
||||
@get:Rule val compose = createRobolectricComposeRule()
|
||||
private val handler = Handler(Looper.getMainLooper())
|
||||
private val connected = GlassesState(present = true, connected = true, controllable = true,
|
||||
displayId = 2, width = 1920, height = 1080, model = "VITURE Luma Ultra",
|
||||
supportsScreen3dof = true, supportsSpatial = true)
|
||||
private lateinit var stateBefore: GlassesState
|
||||
private lateinit var settingsBefore: GlassesSettings
|
||||
private var appBefore: Any? = null
|
||||
private var handlerBefore: Any? = null
|
||||
|
||||
@Before fun prepare() {
|
||||
stateBefore = Glasses.state.value
|
||||
settingsBefore = Glasses.settings.value
|
||||
appBefore = field("app").get(null)
|
||||
handlerBefore = field("handler").get(null)
|
||||
val app = RuntimeEnvironment.getApplication()
|
||||
app.getSharedPreferences("glasses", Context.MODE_PRIVATE).edit().clear().commit()
|
||||
field("app").set(null, app)
|
||||
field("handler").set(null, handler)
|
||||
state().value = GlassesState()
|
||||
settings().value = GlassesSettings()
|
||||
}
|
||||
|
||||
@After fun restore() {
|
||||
handler.removeCallbacksAndMessages(null)
|
||||
state().value = stateBefore
|
||||
settings().value = settingsBefore
|
||||
field("app").set(null, appBefore)
|
||||
field("handler").set(null, handlerBefore)
|
||||
}
|
||||
|
||||
@Test fun globalSetupOffersGlassesWithoutSteamOrAnInstalledRuntime() {
|
||||
show()
|
||||
openGlasses()
|
||||
|
||||
compose.onNodeWithText(text(R.string.setup_glasses_scope)).assertExists()
|
||||
compose.onNodeWithText(text(R.string.setup_glasses_connect)).assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-game").assertDoesNotExist()
|
||||
compose.onNodeWithTag("play-steamvr").assertDoesNotExist()
|
||||
|
||||
compose.onNodeWithText(text(R.string.setup_tab_diagnostics)).performClick()
|
||||
compose.onNodeWithTag("setting-logs").assertExists()
|
||||
openGlasses()
|
||||
compose.onNodeWithText(text(R.string.setup_glasses_connect)).assertExists()
|
||||
}
|
||||
|
||||
@Test fun hotplugKeepsTheGlobalPageAndSharedTrackingPreferences() {
|
||||
val saved = GlassesSettings(positionalTracking = true, handControllers = true)
|
||||
settings().value = saved
|
||||
show()
|
||||
openGlasses()
|
||||
|
||||
compose.runOnIdle { state().value = connected }
|
||||
compose.onNodeWithTag("setting-glasses-3dof").assertExists()
|
||||
compose.onNodeWithTag("setup-glasses-tab-tracking").performScrollTo().performClick()
|
||||
compose.onNodeWithTag("setting-glasses-position").assertExists()
|
||||
|
||||
compose.runOnIdle { state().value = GlassesState() }
|
||||
compose.onNodeWithText(text(R.string.setup_glasses_connect)).assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-position").assertDoesNotExist()
|
||||
assertEquals(saved, Glasses.settings.value)
|
||||
|
||||
compose.runOnIdle { state().value = connected }
|
||||
compose.onNodeWithTag("setting-glasses-position").assertExists()
|
||||
compose.onNodeWithTag("setting-glasses-hands").assert(
|
||||
SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_on)))
|
||||
assertEquals(saved, Glasses.settings.value)
|
||||
}
|
||||
|
||||
@Test fun globalScreenTrackingUsesTheExistingSavedSettings() {
|
||||
state().value = connected
|
||||
settings().value = GlassesSettings(gameOnGlasses = false, headTracking = false)
|
||||
show()
|
||||
openGlasses()
|
||||
compose.onNodeWithTag("setting-glasses-3dof").performScrollTo().performClick()
|
||||
shadowOf(Looper.getMainLooper()).idle()
|
||||
|
||||
assertTrue(Glasses.settings.value.screen3dof)
|
||||
val prefs = RuntimeEnvironment.getApplication().getSharedPreferences("glasses", Context.MODE_PRIVATE)
|
||||
assertTrue(prefs.getBoolean("gameOnGlasses", false))
|
||||
assertTrue(prefs.getBoolean("headTracking", false))
|
||||
assertEquals(GlassesSettings.PICTURE_SCREEN, prefs.getInt("picture3d", -1))
|
||||
|
||||
compose.onNodeWithText(text(R.string.setup_tab_launcher)).performClick()
|
||||
openGlasses()
|
||||
compose.onNodeWithTag("setting-glasses-3dof").assert(
|
||||
SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_on)))
|
||||
}
|
||||
|
||||
private fun openGlasses() {
|
||||
compose.onNodeWithText(text(R.string.setup_tab_glasses)).performClick()
|
||||
}
|
||||
|
||||
private fun show() {
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
CompositionLocalProvider(LocalFrontFocus provides FrontFocus(), LocalNarrowPane provides false) {
|
||||
FocusGlideHost {
|
||||
SetupPanel(FrontEndState(
|
||||
installed = null, ready = false, available = null, busy = false, stage = "", percent = -1,
|
||||
desktopInstalled = false, offlineAccount = null, offline = false, frameGenLabel = "",
|
||||
romsDir = null, logsEnabled = false, steamGames = emptyList(), emulators = emptyList(), running = null,
|
||||
), FrontEndActions(
|
||||
onPlay = {}, onPlayDesktopUi = {}, onSteamGame = {}, onDesktop = {}, onEmulator = {},
|
||||
onRom = {}, onResume = {}, onSteamSettings = {}, onDesktopSettings = {},
|
||||
onInstallPackage = {}, onRemovePackage = {}, onRuntime = {}, onFrameGenPick = {},
|
||||
onImportLossless = {}, onProtons = {}, onComponents = {}, onPerformance = {},
|
||||
onRoms = {}, onFiles = {}, onLogs = {}, onOffline = {},
|
||||
onWirelessAdbPair = { _, _, _, _ -> }, onWirelessAdbApply = { _, _, _, _ -> },
|
||||
onSetPhantomProcessLimit = { _, _ -> },
|
||||
), onOpenDeveloperOptions = {}, onRequestWirelessAdb = {})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun text(id: Int) = RuntimeEnvironment.getApplication().getString(id)
|
||||
private fun field(name: String) = Glasses::class.java.getDeclaredField(name).apply { isAccessible = true }
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
private fun state() = field("_state").get(null) as MutableStateFlow<GlassesState>
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
private fun settings() = field("_settings").get(null) as MutableStateFlow<GlassesSettings>
|
||||
}
|
||||
@@ -0,0 +1,273 @@
|
||||
package com.droiddeck.launcher.ui
|
||||
|
||||
import androidx.compose.ui.test.*
|
||||
import androidx.compose.ui.platform.LocalView
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import com.droiddeck.launcher.glasses.SpatialCalibrationProgress
|
||||
import com.droiddeck.launcher.glasses.SpatialTrackingStatus
|
||||
import com.droiddeck.launcher.glasses.CalibrationDistance
|
||||
import com.droiddeck.launcher.glasses.CalibrationDistanceCheck
|
||||
import com.droiddeck.launcher.R
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Rule
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.RuntimeEnvironment
|
||||
import org.robolectric.annotation.Config
|
||||
import org.robolectric.annotation.GraphicsMode
|
||||
import java.io.File
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [28], qualifiers = "w411dp-h891dp")
|
||||
@GraphicsMode(GraphicsMode.Mode.NATIVE)
|
||||
class SpatialSetupTest {
|
||||
@get:Rule val compose = createRobolectricComposeRule()
|
||||
private lateinit var view: android.view.View
|
||||
|
||||
@Test
|
||||
@Config(qualifiers = "fr-w411dp-h891dp")
|
||||
fun frenchCalibrationControlsKeepTheSelectedDistanceAndActions() {
|
||||
val context = RuntimeEnvironment.getApplication()
|
||||
var selected = 0f
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
view = LocalView.current
|
||||
SpatialSetupScreen(SpatialTrackingStatus(trackingValid = true, synchronized = true),
|
||||
SpatialCalibrationProgress(views = 24, fitted = true), null, "",
|
||||
SpatialSetupActions(validate = { selected = it }))
|
||||
}
|
||||
}
|
||||
compose.onNodeWithText("Configuration spatiale").assertIsDisplayed()
|
||||
compose.onNodeWithText("Spatial setup").assertDoesNotExist()
|
||||
compose.onNodeWithText(context.getString(R.string.spatial_validate)).performScrollTo().performClick()
|
||||
assertEquals(.3048f, selected, .000001f)
|
||||
savePreview("calibration-fr")
|
||||
}
|
||||
|
||||
@Test
|
||||
@Config(qualifiers = "ar-w411dp-h891dp")
|
||||
fun arabicCalibrationDiagnosticsUseTranslatedLabelsAndFormatNumbers() {
|
||||
val context = RuntimeEnvironment.getApplication()
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
view = LocalView.current
|
||||
SpatialSetupScreen(SpatialTrackingStatus(cameraHz = 25f, cameraCopyPermille = 500, frames = 12),
|
||||
SpatialCalibrationProgress(), null, "", SpatialSetupActions())
|
||||
}
|
||||
}
|
||||
compose.onNodeWithText(context.getString(R.string.spatial_title)).assertIsDisplayed()
|
||||
compose.onNodeWithText("Spatial setup").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-spatial-diagnostics").performScrollTo().performClick()
|
||||
compose.onNodeWithText(context.getString(R.string.spatial_input_values, 12.5f, 50f)).performScrollTo().assertIsDisplayed()
|
||||
compose.onNodeWithText("Show diagnostics").assertDoesNotExist()
|
||||
savePreview("calibration-ar")
|
||||
}
|
||||
|
||||
@Test fun directLaunchWithoutConnectedUltraClosesBeforeShowingCalibration() {
|
||||
val field = com.droiddeck.launcher.glasses.Glasses::class.java.getDeclaredField("_state")
|
||||
.apply { isAccessible = true }
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val state = field.get(null) as kotlinx.coroutines.flow.MutableStateFlow<com.droiddeck.launcher.glasses.GlassesState>
|
||||
val previous = state.value
|
||||
try {
|
||||
for (candidate in listOf(previous.copy(connected = false, supportsSpatial = true),
|
||||
previous.copy(connected = true, controllable = true, supportsSpatial = false))) {
|
||||
state.value = candidate
|
||||
val activity = org.robolectric.Robolectric.buildActivity(SpatialTrackingActivity::class.java).create()
|
||||
assertTrue(activity.get().isFinishing)
|
||||
activity.destroy()
|
||||
}
|
||||
} finally { state.value = previous }
|
||||
}
|
||||
|
||||
@Test fun sharedCalibrationIsUsableWithoutClaimingPerDeviceVerification() {
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
SpatialSetupScreen(SpatialTrackingStatus(calibration = true,
|
||||
calibrationSource = "luma-ultra-base", calibrationVerified = false),
|
||||
SpatialCalibrationProgress(fitted = true), null, "", SpatialSetupActions())
|
||||
}
|
||||
}
|
||||
compose.onNodeWithText("Shared Luma Ultra calibration").performScrollTo().assertIsDisplayed()
|
||||
compose.onNodeWithText("Measured calibration verified").assertDoesNotExist()
|
||||
compose.onNodeWithText("Validation required").assertDoesNotExist()
|
||||
compose.onNodeWithText("Hand tracking — Experimental").assertExists()
|
||||
}
|
||||
|
||||
@Test fun pendingRecenterExplainsTheWaitAndBlocksCaptures() {
|
||||
compose.setContent {
|
||||
DroidDeckTheme(Themes.ELECTRIC) {
|
||||
view = LocalView.current
|
||||
SpatialSetupScreen(SpatialTrackingStatus(message = "Hold still while tracking stabilizes", recenterPending = true),
|
||||
SpatialCalibrationProgress(collecting = true), null, "", SpatialSetupActions())
|
||||
}
|
||||
}
|
||||
compose.onNodeWithText("Hold still while tracking stabilizes").assertExists()
|
||||
compose.onNodeWithText("Waiting for tracking…").assertIsNotEnabled()
|
||||
savePreview("tracking-recovery")
|
||||
compose.onNodeWithText("Capture board view").performScrollTo().assertIsNotEnabled()
|
||||
}
|
||||
|
||||
@Test fun completedFitValidatesTheSelectedImperialOrMetricDistance() {
|
||||
var distance = 0f
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
view = LocalView.current
|
||||
SpatialSetupScreen(SpatialTrackingStatus(trackingValid = true, synchronized = true),
|
||||
SpatialCalibrationProgress(collecting = true, views = 24, fitted = true), null, "Ready to validate",
|
||||
SpatialSetupActions(validate = { distance = it }))
|
||||
}
|
||||
}
|
||||
compose.onNodeWithText("Validate distance").performScrollTo().performClick()
|
||||
assertEquals(0.3048f, distance, 0.000001f)
|
||||
savePreview("distance-check")
|
||||
for (choice in CalibrationDistance.entries.drop(1)) {
|
||||
compose.onNodeWithTag("setting-calibration-distance").performScrollTo().performClick()
|
||||
compose.onNodeWithText(RuntimeEnvironment.getApplication().getString(choice.labelRes)).performClick()
|
||||
compose.onNodeWithText("Validate distance").performScrollTo().performClick()
|
||||
assertEquals(choice.meters, distance, 0.000001f)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun captureRejectionAppearsBesideTheCounter() {
|
||||
val reason = "Capture rejected: 4 / 12 required corners visible in both cameras."
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
SpatialSetupScreen(SpatialTrackingStatus(trackingValid = true, synchronized = true),
|
||||
SpatialCalibrationProgress(collecting = true, views = 2, captureMessage = reason), null, "",
|
||||
SpatialSetupActions())
|
||||
}
|
||||
}
|
||||
compose.onNodeWithText("Capture board view").performScrollTo().assertIsEnabled()
|
||||
compose.onNodeWithText("2 / 24 views captured").assertIsDisplayed()
|
||||
compose.onNodeWithText(reason).assertIsDisplayed()
|
||||
}
|
||||
|
||||
@Test fun pendingCaptureCannotQueueAnotherPress() {
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
SpatialSetupScreen(SpatialTrackingStatus(trackingValid = true, synchronized = true),
|
||||
SpatialCalibrationProgress(collecting = true, capturing = true), null, "", SpatialSetupActions())
|
||||
}
|
||||
}
|
||||
compose.onNodeWithText("Capturing…").performScrollTo().assertIsNotEnabled()
|
||||
}
|
||||
|
||||
@Test fun distanceResultAppearsBesideValidationButton() {
|
||||
val reason=CalibrationDistanceCheck.evaluate(RuntimeEnvironment.getApplication(),.3048f,3,null).message
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
view=LocalView.current
|
||||
SpatialSetupScreen(SpatialTrackingStatus(trackingValid=true,synchronized=true),
|
||||
SpatialCalibrationProgress(views=25,fitted=true,validationMessage=reason),null,
|
||||
"Fit 1.12 px. Measure the distance, then validate.",SpatialSetupActions())
|
||||
}
|
||||
}
|
||||
compose.onNodeWithText("Validate distance").performScrollTo().assertIsEnabled()
|
||||
compose.onNodeWithText(reason).assertIsDisplayed()
|
||||
savePreview("distance-result")
|
||||
}
|
||||
|
||||
@Test fun pendingDistanceCheckShowsFeedbackAndPreventsDuplicateRequests() {
|
||||
val message="Checking the next camera image. Keep the full board visible and hold still."
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
SpatialSetupScreen(SpatialTrackingStatus(trackingValid=true,synchronized=true),
|
||||
SpatialCalibrationProgress(views=25,fitted=true,validating=true,validationMessage=message),null,
|
||||
"Fit complete",SpatialSetupActions())
|
||||
}
|
||||
}
|
||||
compose.onNodeWithText("Checking distance…").performScrollTo().assertIsNotEnabled()
|
||||
compose.onNodeWithText(message).assertIsDisplayed()
|
||||
}
|
||||
|
||||
@Test fun restoredCapturesCanBeRecalculatedWithoutMixingNewTrackingFrames() {
|
||||
var solves=0
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
SpatialSetupScreen(SpatialTrackingStatus(trackingValid = true, synchronized = true),
|
||||
SpatialCalibrationProgress(views = 35, captureMessage = "35 saved views restored."), null,
|
||||
"Head-to-camera alignment varies by 25 cm (9.84 in).",
|
||||
SpatialSetupActions(solve = { solves++ }))
|
||||
}
|
||||
}
|
||||
compose.onNodeWithText("Capture board view").performScrollTo().assertIsNotEnabled()
|
||||
compose.onNodeWithText("35 saved views restored.").assertIsDisplayed()
|
||||
compose.onNodeWithText("Calculate calibration").performScrollTo().assertIsEnabled().performClick()
|
||||
assertEquals(1,solves)
|
||||
}
|
||||
|
||||
@Test
|
||||
@Config(qualifiers = "w840dp-h360dp-land")
|
||||
fun landscapeSetupLeavesMostOfTheHeightForScrolling() {
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
view = LocalView.current
|
||||
SpatialSetupScreen(SpatialTrackingStatus(trackingValid = true, synchronized = true),
|
||||
SpatialCalibrationProgress(views = 35), null, "Ready to calculate", SpatialSetupActions())
|
||||
}
|
||||
}
|
||||
compose.waitForIdle()
|
||||
val page=compose.onNodeWithTag("spatial-setup-page").fetchSemanticsNode().boundsInRoot
|
||||
val viewport=compose.onNode(hasScrollAction()).fetchSemanticsNode().boundsInRoot
|
||||
assertTrue("Calibration controls need at least 75% of the page height", viewport.height >= page.height*.75f)
|
||||
savePreview("landscape-compact")
|
||||
}
|
||||
|
||||
@Test fun diagnosticsSeparateCameraRateFromDeliberatelySkippedFrames() {
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
SpatialSetupScreen(SpatialTrackingStatus(cameraHz = 25f, cameraFrameDivisor = 2, cameraCopyPermille = 500,
|
||||
frames = 12, dropped = 3, rateLimitedFrames = 15),
|
||||
SpatialCalibrationProgress(), null, "", SpatialSetupActions())
|
||||
}
|
||||
}
|
||||
compose.onNodeWithTag("setting-spatial-diagnostics").performScrollTo().performClick()
|
||||
compose.onNodeWithText("Input limit 12.5 Hz • 50% of camera frames. Head tracking stays at full rate.").assertExists()
|
||||
compose.onNodeWithText("12 processed • 3 dropped • 15 skipped by input limit").assertExists()
|
||||
compose.onNodeWithText("25.0 Hz", substring = true).assertExists()
|
||||
}
|
||||
|
||||
@Test fun diagnosticsShowTheAdaptiveFractionInsteadOfTheLegacyDivisor() {
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
SpatialSetupScreen(SpatialTrackingStatus(cameraHz = 25f, cameraFrameDivisor = 1, cameraCopyPermille = 600),
|
||||
SpatialCalibrationProgress(), null, "", SpatialSetupActions())
|
||||
}
|
||||
}
|
||||
compose.onNodeWithTag("setting-spatial-diagnostics").performScrollTo().performClick()
|
||||
compose.onNodeWithText("Input limit 15.0 Hz • 60% of camera frames. Head tracking stays at full rate.").assertExists()
|
||||
}
|
||||
|
||||
@Test fun manualRateControlBecomesAvailableAfterAutomaticRateIsDisabled() {
|
||||
val automatic=mutableStateOf(true)
|
||||
val halfRate=mutableStateOf(true)
|
||||
compose.setContent {
|
||||
DroidDeckTheme {
|
||||
SpatialSetupScreen(SpatialTrackingStatus(), SpatialCalibrationProgress(), null, "",
|
||||
SpatialSetupActions(adaptive = { automatic.value=it }, halfRate = { halfRate.value=it }),
|
||||
halfRate = halfRate.value, adaptive = automatic.value)
|
||||
}
|
||||
}
|
||||
compose.onNodeWithTag("setting-spatial-diagnostics").performScrollTo().performClick()
|
||||
compose.onNodeWithTag("setting-spatial-half-rate").assertDoesNotExist()
|
||||
compose.onNodeWithTag("setting-spatial-adaptive-rate").performScrollTo().performClick()
|
||||
compose.onNodeWithTag("setting-spatial-half-rate").performScrollTo().performClick()
|
||||
assertEquals(false,automatic.value)
|
||||
assertEquals(false,halfRate.value)
|
||||
}
|
||||
|
||||
private fun savePreview(name: String) {
|
||||
val file = File("build/reports/spatial-setup/$name.png")
|
||||
file.parentFile?.mkdirs()
|
||||
compose.runOnIdle {
|
||||
val root = view.rootView
|
||||
val bitmap = android.graphics.Bitmap.createBitmap(root.width, root.height, android.graphics.Bitmap.Config.ARGB_8888)
|
||||
root.draw(android.graphics.Canvas(bitmap))
|
||||
file.outputStream().use { bitmap.compress(android.graphics.Bitmap.CompressFormat.PNG, 100, it) }
|
||||
bitmap.recycle()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
package com.droiddeck.launcher.ui
|
||||
|
||||
import android.graphics.Bitmap
|
||||
import android.graphics.Canvas
|
||||
import android.view.View
|
||||
import androidx.compose.ui.graphics.toArgb
|
||||
import com.droiddeck.launcher.glasses.TrackingRecovery
|
||||
import org.junit.Assert.*
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.RuntimeEnvironment
|
||||
import org.robolectric.annotation.Config
|
||||
import org.robolectric.annotation.GraphicsMode
|
||||
import java.io.File
|
||||
import kotlin.math.abs
|
||||
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk=[34])
|
||||
@GraphicsMode(GraphicsMode.Mode.NATIVE)
|
||||
class TrackingRecoveryViewTest {
|
||||
private fun view()=TrackingRecoveryView(RuntimeEnvironment.getApplication())
|
||||
private fun render(view: View, width: Int=1920, height: Int=1200): Bitmap {
|
||||
view.measure(View.MeasureSpec.makeMeasureSpec(width,View.MeasureSpec.EXACTLY),View.MeasureSpec.makeMeasureSpec(height,View.MeasureSpec.EXACTLY))
|
||||
view.layout(0,0,width,height)
|
||||
return Bitmap.createBitmap(width,height,Bitmap.Config.ARGB_8888).also { view.draw(Canvas(it)) }
|
||||
}
|
||||
private fun save(bitmap: Bitmap, name: String) {
|
||||
val file=File("build/reports/tracking-recovery/$name.png");file.parentFile!!.mkdirs()
|
||||
file.outputStream().use { bitmap.compress(Bitmap.CompressFormat.PNG,100,it) }
|
||||
}
|
||||
|
||||
@Test fun recoveredTrackingRemovesTheScreenAndItsTouchTarget() {
|
||||
val view=view()
|
||||
assertEquals(View.GONE,view.visibility)
|
||||
view.update(TrackingRecovery.LOST,false)
|
||||
assertEquals(View.VISIBLE,view.visibility)
|
||||
assertTrue(view.contentDescription.contains("Look around slowly"))
|
||||
assertTrue(view.isClickable)
|
||||
view.update(null,false)
|
||||
assertEquals(View.GONE,view.visibility)
|
||||
assertNull(view.contentDescription)
|
||||
}
|
||||
|
||||
@Test fun everyRecoveryStateHasItsOwnActionAndFitsThePhone() {
|
||||
val view=view()
|
||||
for((state,instruction) in listOf(TrackingRecovery.LOST to "Look around slowly",TrackingRecovery.RECENTER to "tap Recenter",
|
||||
TrackingRecovery.STABILIZING to "Keep the glasses steady",TrackingRecovery.DISCONNECTED to "USB-access prompt")) {
|
||||
view.update(state,false,Themes.byId(Themes.ELECTRIC))
|
||||
assertTrue(view.contentDescription.contains(instruction))
|
||||
render(view,1080,600).also { save(it,"phone-${state.name.lowercase()}");it.recycle() }
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun stereoDuplicatesTheWholeMessageForEachEyeAndMatchesMono() {
|
||||
val view=view();view.update(TrackingRecovery.LOST,false)
|
||||
val mono=render(view)
|
||||
try {
|
||||
view.update(TrackingRecovery.LOST,true)
|
||||
val stereo=render(view,3840,1200)
|
||||
try {
|
||||
save(mono,"glasses-mono");save(stereo,"glasses-stereo")
|
||||
val expected=IntArray(mono.width)
|
||||
val eye=IntArray(mono.width)
|
||||
val pixels=mono.width*mono.height
|
||||
for(x in listOf(0,mono.width)) {
|
||||
var changed=0
|
||||
var difference=0L
|
||||
for(y in 0 until mono.height) {
|
||||
mono.getPixels(expected,0,mono.width,0,y,mono.width,1)
|
||||
stereo.getPixels(eye,0,mono.width,x,y,mono.width,1)
|
||||
for(i in eye.indices) {
|
||||
val actual=eye[i]
|
||||
val reference=expected[i]
|
||||
if(actual!=reference) changed++
|
||||
difference+=abs((actual and 255)-(reference and 255))
|
||||
difference+=abs(((actual ushr 8) and 255)-((reference ushr 8) and 255))
|
||||
difference+=abs(((actual ushr 16) and 255)-((reference ushr 16) and 255))
|
||||
}
|
||||
}
|
||||
// Native text rasterization can round a translated glyph edge differently.
|
||||
assertTrue("Eye at x=$x changed $changed pixels",changed<pixels/1000)
|
||||
assertTrue("Eye at x=$x has different content",difference.toDouble()/(pixels*3)<0.1)
|
||||
}
|
||||
} finally {
|
||||
stereo.recycle()
|
||||
}
|
||||
} finally {
|
||||
mono.recycle()
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun activePaletteChangesTheBackgroundAndMessageColors() {
|
||||
val view=view()
|
||||
for(theme in listOf(Themes.GRAPHITE,Themes.ELECTRIC,Themes.PAPER)) {
|
||||
val palette=Themes.byId(theme)
|
||||
view.update(TrackingRecovery.LOST,false,palette)
|
||||
val bitmap=render(view)
|
||||
try {
|
||||
assertEquals(palette.background.toArgb(),bitmap.getPixel(0,0))
|
||||
val row=IntArray(bitmap.width)
|
||||
val textColor=palette.onBackground.toArgb()
|
||||
var foundTextColor=false
|
||||
for(y in 0 until bitmap.height) {
|
||||
bitmap.getPixels(row,0,bitmap.width,0,y,bitmap.width,1)
|
||||
if(row.any { it==textColor }) {
|
||||
foundTextColor=true
|
||||
break
|
||||
}
|
||||
}
|
||||
assertTrue("Missing message color for theme $theme",foundTextColor)
|
||||
save(bitmap,"theme-$theme")
|
||||
} finally {
|
||||
bitmap.recycle()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user