Windows port: drop the CN1_HAVE_WINRT guard, always compile real WinRT

The guard was defensive insurance against a build toolchain lacking WinRT, but the
cross-compile CI proved otherwise: it had already DEFINED CN1_HAVE_WINRT (the
earlier STL error fired inside the #ifdef on the Linux/xwin leg), i.e. the
xwin-laid-out SDK ships the WinRT ABI headers + runtimeobject. So stub mode never
actually triggered anywhere the port builds.

Remove the CMake probe + the per-function #ifdef/#else stub branches and link
runtimeobject unconditionally; the compiled output is identical to the prior green
build, just simpler. Also drop the now-pointless locationSupported() native
(getLocationManager always returns the manager; isNativeShareSupported checks for
a host window). Each service still degrades honestly at RUNTIME (no device /
disabled / denied -> false/null). status.md updated to drop the gate/stub language.

Trade-off (accepted): a future build SDK without WinRT would now fail the build
instead of degrading to stubs.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: shai-almog

Ports/WindowsPort/nativeSources/cn1_windows_winrt.cpp

@@ -22,26 +22,24 @@
  */
 
 /*
- * WinRT-backed services for the Windows port (biometric / Windows Hello, and --
- * added incrementally -- location, contacts, share). WinRT is consumed through
- * the WRL ABI projection (RoGetActivationFactory + the ABI:: interfaces), the
- * same COM-based mechanism the Media Foundation layer already uses, so no
- * C++/WinRT (cppwinrt) projection headers are required.
+ * WinRT-backed services for the Windows port: biometric (Windows Hello), location,
+ * contacts and system share. WinRT is consumed through the WRL ABI projection
+ * (RoGetActivationFactory / RoActivateInstance + the ABI:: interfaces), the same
+ * COM-based mechanism the Media Foundation layer already uses -- no C++/WinRT
+ * (cppwinrt) projection headers are required, and runtimeobject.lib is linked
+ * unconditionally. The WinRT ABI headers + runtimeobject ship in every Windows
+ * SDK the port builds against, including the xwin-laid-out SDK used by the
+ * Windows-free Linux cross-compile (verified by that CI leg compiling this file).
  *
- * The whole real implementation is gated on CN1_HAVE_WINRT, which the generated
- * CMake defines only after a probe confirms the WinRT ABI headers +
- * runtimeobject.lib are present and link on the build toolchain. When it is not
- * defined (e.g. a cross-compile sysroot without WinRT) every bridge below
- * compiles as an honest "unsupported" stub, so the Windows-free build stays green
- * and the matching CN1 capability simply reports false / null.
+ * Each bridge still degrades honestly at RUNTIME -- a missing device, disabled
+ * Windows setting or denied permission surfaces as false / null (never fabricated
+ * data) -- which is what the matching CN1 capability reports as "unsupported".
  */
 
 #ifdef _WIN32
 
 #include "cn1_windows.h"
 
-#ifdef CN1_HAVE_WINRT
-
 #include <roapi.h>
 #include <stdlib.h>
 #include <string.h>
@@ -74,10 +72,9 @@ using namespace Microsoft::WRL::Wrappers;
 /* Blocks the calling (CN1 worker) thread until a WinRT IAsyncOperation<T>
  * completes, then fetches its result. Used for the inherently-async WinRT APIs;
  * callers invoke these natives off the EDT (via AsyncResource) so blocking is
- * fine. */
-/* TOp is the operation's logical result type (a value type, or a runtimeclass --
- * for which GetResults yields the ABI *interface* pointer, so the result pointer
- * type TResultPtr is kept separate from TOp). */
+ * fine. TOp is the operation's logical result type (a value type, or a
+ * runtimeclass -- for which GetResults yields the ABI *interface* pointer, so the
+ * result pointer type TResultPtr is kept separate from TOp). */
 template <typename TOp, typename TResultPtr>
 static HRESULT cn1AwaitOp(IAsyncOperation<TOp>* op, TResultPtr result) {
     Event done(CreateEventExW(nullptr, nullptr, 0, EVENT_ALL_ACCESS));
@@ -162,18 +159,15 @@ static void cn1AppendHString(CN1Buf* out, HSTRING h) {
     free(tmp);
 }
 
-#endif /* CN1_HAVE_WINRT */
-
 extern "C" {
 
 /* ------------------------------------------------------------- biometric
  *
  * Maps Windows Hello (UserConsentVerifier) to com.codename1.security.Biometrics.
  * Returns the UserConsentVerifierAvailability enum: 0 Available, 1
  * DeviceNotPresent, 2 NotConfiguredForUser, 3 DisabledByPolicy, 4 DeviceBusy.
- * The Java side treats 0 as supported+ready. The stub reports DeviceNotPresent. */
+ * The Java side treats 0 as supported+ready; anything else degrades honestly. */
 JAVA_INT com_codename1_impl_windows_WindowsNative_biometricAvailability___R_int(CODENAME_ONE_THREAD_STATE) {
-#ifdef CN1_HAVE_WINRT
     cn1WinRtInit();
     ComPtr<IUserConsentVerifierStatics> statics;
     HRESULT hr = RoGetActivationFactory(
@@ -191,16 +185,12 @@ JAVA_INT com_codename1_impl_windows_WindowsNative_biometricAvailability___R_int(
         return 1;
     }
     return (JAVA_INT) avail;
-#else
-    return 1; /* DeviceNotPresent: no WinRT -> report unsupported */
-#endif
 }
 
 /* Shows the Windows Hello consent prompt with the given reason; returns true
- * when the user is verified. Stub returns false. */
+ * when the user is verified. */
 JAVA_BOOLEAN com_codename1_impl_windows_WindowsNative_biometricAuthenticate___java_lang_String_R_boolean(
         CODENAME_ONE_THREAD_STATE, JAVA_OBJECT message) {
-#ifdef CN1_HAVE_WINRT
     cn1WinRtInit();
     ComPtr<IUserConsentVerifierStatics> statics;
     HRESULT hr = RoGetActivationFactory(
@@ -225,32 +215,17 @@ JAVA_BOOLEAN com_codename1_impl_windows_WindowsNative_biometricAuthenticate___ja
         return JAVA_FALSE;
     }
     return result == UserConsentVerificationResult_Verified ? JAVA_TRUE : JAVA_FALSE;
-#else
-    (void) message;
-    return JAVA_FALSE;
-#endif
-}
-
-/* True when the port was built with WinRT (so a real Geolocator can be used);
- * lets getLocationManager() return null honestly on a stub build. */
-JAVA_BOOLEAN com_codename1_impl_windows_WindowsNative_locationSupported___R_boolean(CODENAME_ONE_THREAD_STATE) {
-#ifdef CN1_HAVE_WINRT
-    return JAVA_TRUE;
-#else
-    return JAVA_FALSE;
-#endif
 }
 
 /* -------------------------------------------------------------- location
  *
  * Maps Windows.Devices.Geolocation.Geolocator to LocationManager. Fills `out`
  * with [latitude, longitude, accuracy(m), altitude(m), direction(deg),
- * velocity(m/s), timestampMillis] and returns true; false when location is
- * unavailable / disabled (Windows location off, or WinRT stub build) so the
- * port reports unsupported honestly rather than fabricating a position. */
+ * velocity(m/s)] and returns true; false when location is unavailable / disabled
+ * (Windows location off or permission denied) so the port reports unsupported
+ * honestly rather than fabricating a position. */
 JAVA_BOOLEAN com_codename1_impl_windows_WindowsNative_locationGetCurrent___double_1ARRAY_R_boolean(
         CODENAME_ONE_THREAD_STATE, JAVA_OBJECT outArr) {
-#ifdef CN1_HAVE_WINRT
     if (outArr == JAVA_NULL) {
         return JAVA_FALSE;
     }
@@ -305,10 +280,6 @@ JAVA_BOOLEAN com_codename1_impl_windows_WindowsNative_locationGetCurrent___doubl
     if (n > 4) { out[4] = heading; }
     if (n > 5) { out[5] = speed; }
     return JAVA_TRUE;
-#else
-    (void) outArr;
-    return JAVA_FALSE;
-#endif
 }
 
 /* -------------------------------------------------------------- contacts
@@ -317,10 +288,9 @@ JAVA_BOOLEAN com_codename1_impl_windows_WindowsNative_locationGetCurrent___doubl
  * single record-delimited blob: each contact is "id US name US phone US email"
  * (field separator 0x1F, record separator 0x1E). The Java side parses it into CN1
  * Contact objects. One native call avoids a chatty per-field bridge. Returns null
- * when the store is inaccessible (no WinRT, or access denied) and an empty string
- * when the store simply has no contacts -- both honest, never fabricated. */
+ * when the store is inaccessible (access denied) and an empty string when the
+ * store simply has no contacts -- both honest, never fabricated. */
 JAVA_OBJECT com_codename1_impl_windows_WindowsNative_contactsGetAll___R_java_lang_String(CODENAME_ONE_THREAD_STATE) {
-#ifdef CN1_HAVE_WINRT
     cn1WinRtInit();
     ComPtr<IContactManagerStatics2> statics;
     if (FAILED(RoGetActivationFactory(
@@ -408,9 +378,6 @@ JAVA_OBJECT com_codename1_impl_windows_WindowsNative_contactsGetAll___R_java_lan
         free(blob.data);
         return s;
     }
-#else
-    return JAVA_NULL;
-#endif
 }
 
 /* ----------------------------------------------------------------- share
@@ -421,15 +388,12 @@ JAVA_OBJECT com_codename1_impl_windows_WindowsNative_contactsGetAll___R_java_lan
  * and cn1WinShareHandleMessage runs here on the pump thread. The text/title are
  * stashed in file-static state read by the (same-thread) DataRequested handler.
  * Shares text (the common case); image-file sharing is a later addition. */
-#ifdef CN1_HAVE_WINRT
 static WCHAR* g_shareTextW = NULL;
 static WCHAR* g_shareTitleW = NULL;
 static bool g_shareHandlerRegistered = false;
 static ComPtr<IDataTransferManager> g_shareDtm;
-#endif
 
 void cn1WinShareHandleMessage(WPARAM wParam) {
-#ifdef CN1_HAVE_WINRT
     /* wParam carries [textW, titleW] allocated by the caller; take ownership. */
     WCHAR** data = (WCHAR**) wParam;
     if (g_shareTextW != NULL) { free(g_shareTextW); }
@@ -475,16 +439,12 @@ void cn1WinShareHandleMessage(WPARAM wParam) {
         g_shareHandlerRegistered = true;
     }
     interop->ShowShareUIForWindow(cn1Win.hwnd);
-#else
-    (void) wParam;
-#endif
 }
 
 /* Java bridge: marshals the share request to the window thread. Returns false in
- * headless / WinRT-less builds. */
+ * headless mode (no host window). */
 JAVA_BOOLEAN com_codename1_impl_windows_WindowsNative_shareText___java_lang_String_java_lang_String_R_boolean(
         CODENAME_ONE_THREAD_STATE, JAVA_OBJECT textObj, JAVA_OBJECT titleObj) {
-#ifdef CN1_HAVE_WINRT
     if (cn1Win.hwnd == NULL) {
         return JAVA_FALSE;
     }
@@ -496,11 +456,6 @@ JAVA_BOOLEAN com_codename1_impl_windows_WindowsNative_shareText___java_lang_Stri
     data[1] = titleObj != JAVA_NULL ? cn1WinJavaStringToWide(threadStateData, titleObj, NULL) : NULL;
     PostMessageW(cn1Win.hwnd, WM_CN1_SHARE, (WPARAM) data, 0);
     return JAVA_TRUE;
-#else
-    (void) textObj;
-    (void) titleObj;
-    return JAVA_FALSE;
-#endif
 }
 
 } /* extern "C" */

Ports/WindowsPort/src/com/codename1/impl/windows/WindowsImplementation.java

@@ -355,16 +355,12 @@ public com.codename1.security.Biometrics getBiometrics() {
         return biometrics;
     }
 
-    // WinRT Geolocator-backed location. Returns null (unsupported) on a build
-    // without WinRT; on a real build getCurrentLocation reports OUT_OF_SERVICE
-    // honestly when Windows location is disabled.
+    // WinRT Geolocator-backed location. getCurrentLocation reports OUT_OF_SERVICE
+    // honestly when Windows location is disabled / denied.
     private com.codename1.location.LocationManager locationManager;
 
     @Override
     public com.codename1.location.LocationManager getLocationManager() {
-        if (!WindowsNative.locationSupported()) {
-            return null;
-        }
         if (locationManager == null) {
             locationManager = new WindowsLocationManager();
         }
@@ -1831,9 +1827,9 @@ public int getSMSSupport() {
 
     @Override
     public boolean isNativeShareSupported() {
-        // locationSupported() reports whether WinRT was compiled in (the gate the
-        // whole WinRT layer shares); the share UI also needs a host window.
-        return WindowsNative.locationSupported();
+        // The WinRT DataTransferManager share UI is always compiled in; it just
+        // needs a host window (absent only in headless screenshot mode).
+        return getDisplayWidth() > 0;
     }
 
     @Override

Ports/WindowsPort/src/com/codename1/impl/windows/WindowsNative.java

@@ -518,9 +518,6 @@ public static native long editStringAt(int x, int y, int w, int h, String text,
 
     /* -------------------------------------------------- location (WinRT) */
 
-    /** True when WinRT is compiled in, so a real {@code Geolocator} is available. */
-    public static native boolean locationSupported();
-
     /**
      * Fills {@code out} with the current fix [latitude, longitude, accuracy(m),
      * altitude(m), direction(deg), velocity(m/s)] from the WinRT Geolocator and

Ports/WindowsPort/status.md

@@ -149,9 +149,8 @@ the port does not have yet (gap 5a). `captureVideo` is likewise still to do.
 marshals to the window thread (`WM_CN1_SHARE`), where `IDataTransferManagerInterop`
 `GetForWindow` + `ShowShareUIForWindow` open the system share flyout for the
 unpackaged Win32 window and a `DataRequested` handler supplies the text/title
-(`cn1_windows_winrt.cpp`, same `CN1_HAVE_WINRT` gate). Shares text today (the
-common case); image-file sharing via `SetStorageItems` is a follow-up. Compiles
-(real + stub) on the Windows ARM64 VM; the flyout itself is interactive.
+(`cn1_windows_winrt.cpp`, shared WinRT layer). Shares text today (the
+common case); image-file sharing via `SetStorageItems` is a follow-up. Compiles and links on the Windows ARM64 VM; the flyout itself is interactive.
 
 **Print — not applicable.** Codename One core exposes no printing API (no
 `Printer` class or impl hook), so there is nothing for the port to override; this
@@ -171,7 +170,7 @@ they stay honest until backed by a real implementation:
 
 **Contacts — implemented (WinRT).** `getAllContacts` / `getContactById` read the
 user's contacts via the WinRT `ContactStore` (`cn1_windows_winrt.cpp`, same
-`CN1_HAVE_WINRT` gate). One native call returns every contact as a delimited blob
+shared WinRT layer). One native call returns every contact as a delimited blob
 (id / name / phone / email) which the impl parses and briefly caches, so the
 base's id-then-fetch loop shares a single store read. Returns nothing when the
 store is inaccessible (no WinRT / access denied) -- honest, never fabricated.
@@ -180,12 +179,12 @@ biometric/location.
 
 **Location / GPS — implemented (WinRT).** `getLocationManager()` →
 `WindowsLocationManager`, backed by the WinRT `Geolocator`
-(`cn1_windows_winrt.cpp`, same `CN1_HAVE_WINRT` gate). `getCurrentLocation` /
+(`cn1_windows_winrt.cpp`, shared WinRT layer). `getCurrentLocation` /
 `getLastKnownLocation` resolve one fix (lat/lon/accuracy/altitude/heading/speed);
 a continuous `LocationListener` is served by a polling thread. When Windows
 location is disabled or no provider answers, it reports `OUT_OF_SERVICE` / throws
-rather than fabricating a position; `getLocationManager` returns `null` on a
-WinRT-less build. Verified on the Windows ARM64 VM: the `Geolocator` activates and
+rather than fabricating a position. Verified on the Windows ARM64 VM: the
+`Geolocator` activates and
 `GetGeopositionAsync` returns `E_ACCESSDENIED` (location off on the VM), which the
 port surfaces honestly as unavailable.
 
@@ -194,13 +193,15 @@ port surfaces honestly as unavailable.
 / PIN). `isSupported()` / `canAuthenticate()` map to `CheckAvailabilityAsync`;
 `authenticate(...)` runs the system Hello prompt off the EDT and completes the
 `AsyncResource`. WinRT is consumed via the WRL ABI projection
-(`cn1_windows_winrt.cpp`), gated on `CN1_HAVE_WINRT` (the generated CMake probes
-the toolchain and defines it only when the WinRT ABI headers + `runtimeobject`
-link), so a cross-compile sysroot without WinRT compiles the natives as honest
-"unsupported" stubs and stays green — the same gating model as WebView2. Verified
-on a real Windows ARM64 VM: the WRL pattern activates the factory and awaits the
-async op; the VM correctly reports `DeviceNotPresent` (no Hello hardware), so the
-port reports unsupported there and a real Hello-equipped laptop reports available.
+(`cn1_windows_winrt.cpp`) -- the same COM mechanism the Media Foundation layer
+uses, no C++/WinRT needed -- and `runtimeobject` is linked unconditionally: the
+WinRT ABI headers + import lib ship in every Windows SDK the port builds against,
+including the `xwin`-laid-out SDK the Windows-free Linux cross-compile uses (that
+CI leg compiles this file, confirming it). The natives still degrade honestly at
+runtime (no device / disabled / denied → `false`/`null`). Verified on a real
+Windows ARM64 VM: the WRL pattern activates the factory and awaits the async op;
+the VM correctly reports `DeviceNotPresent` (no Hello hardware), so the port
+reports unsupported there and a real Hello-equipped laptop reports available.
 
 **Audio recording — implemented.** `createMediaRecorder` / `captureAudio` record
 from the default microphone via the classic `waveIn` (winmm) API to a 16-bit PCM

vm/ByteCodeTranslator/src/com/codename1/tools/translator/ByteCodeTranslator.java

@@ -758,7 +758,12 @@ private static void writeCmakeProject(File projectRoot, File srcRoot, String app
                 // comdlg32: GetOpenFileNameW/GetSaveFileNameW (native file picker).
                 // crypt32: CryptProtectData/CryptUnprotectData (DPAPI secure storage).
                 // winmm: waveIn audio recording (cn1_windows_audiorec.c).
-                writer.append("    target_link_libraries(${PROJECT_NAME} d2d1 dwrite dxgi windowscodecs winhttp ws2_32 user32 gdi32 ole32 oleaut32 uuid mf mfplat mfreadwrite mfuuid shell32 comdlg32 crypt32 winmm)\n");
+                // runtimeobject: WinRT activation (RoGetActivationFactory) for the
+                //   biometric / location / contacts / share natives (cn1_windows_winrt.cpp).
+                //   The WinRT ABI headers + this import lib ship in every Windows SDK the
+                //   port builds against, including the xwin-laid-out SDK the Linux
+                //   cross-compile uses, so it is linked unconditionally.
+                writer.append("    target_link_libraries(${PROJECT_NAME} d2d1 dwrite dxgi windowscodecs winhttp ws2_32 user32 gdi32 ole32 oleaut32 uuid mf mfplat mfreadwrite mfuuid shell32 comdlg32 crypt32 winmm runtimeobject)\n");
                 // BrowserComponent is backed by WebView2 (cn1_windows_browser.cpp),
                 // gated on the SDK being present: when WEBVIEW2_SDK_DIR points at a
                 // Microsoft.Web.WebView2 build/native folder we link the static
@@ -778,36 +783,6 @@ private static void writeCmakeProject(File projectRoot, File srcRoot, String app
                 writer.append("        endif()\n");
                 writer.append("        target_link_libraries(${PROJECT_NAME} shlwapi version shell32 advapi32)\n");
                 writer.append("    endif()\n");
-                // WinRT-backed services (biometric / location / contacts / share) are
-                // consumed through the WRL ABI projection. The WinRT ABI headers
-                // (windows.security.credentials.ui.h etc.) and runtimeobject.lib are
-                // part of a full Windows SDK but may be absent from a cross-compile
-                // sysroot (e.g. an xwin splat), so probe the toolchain: only when a
-                // minimal WinRT translation unit compiles + links is CN1_HAVE_WINRT
-                // defined and runtimeobject linked -- otherwise those natives compile
-                // as stubs and the matching capabilities report unsupported, exactly
-                // like the WebView2 gate above. This keeps the Windows-free cross-compile
-                // green while the real services light up on a Windows-host build.
-                writer.append("    include(CheckCXXSourceCompiles)\n");
-                writer.append("    set(CMAKE_REQUIRED_FLAGS \"/EHsc /std:c++17\")\n");
-                writer.append("    set(CMAKE_REQUIRED_LIBRARIES runtimeobject)\n");
-                writer.append("    check_cxx_source_compiles(\"\n");
-                writer.append("#include <roapi.h>\n");
-                writer.append("#include <wrl.h>\n");
-                writer.append("#include <wrl/wrappers/corewrappers.h>\n");
-                writer.append("#include <windows.foundation.h>\n");
-                writer.append("#include <windows.security.credentials.ui.h>\n");
-                writer.append("using namespace ABI::Windows::Security::Credentials::UI;\n");
-                writer.append("int main(){ Microsoft::WRL::Wrappers::RoInitializeWrapper i(RO_INIT_MULTITHREADED);\n");
-                writer.append("  Microsoft::WRL::ComPtr<IUserConsentVerifierStatics> s;\n");
-                writer.append("  RoGetActivationFactory(Microsoft::WRL::Wrappers::HStringReference(RuntimeClass_Windows_Security_Credentials_UI_UserConsentVerifier).Get(), IID_PPV_ARGS(&s)); return 0; }\n");
-                writer.append("\" CN1_WINRT_AVAILABLE)\n");
-                writer.append("    unset(CMAKE_REQUIRED_FLAGS)\n");
-                writer.append("    unset(CMAKE_REQUIRED_LIBRARIES)\n");
-                writer.append("    if(CN1_WINRT_AVAILABLE)\n");
-                writer.append("        target_compile_definitions(${PROJECT_NAME} PRIVATE CN1_HAVE_WINRT=1)\n");
-                writer.append("        target_link_libraries(${PROJECT_NAME} runtimeobject)\n");
-                writer.append("    endif()\n");
                 // Release is the shipping default: optimized (/O2 from the Release
                 // config) and stripped -- no debug info, and the linker dead-strips
                 // unreferenced functions (/OPT:REF) and folds identical COMDATs