Windows port: contacts via WinRT ContactStore

Implements getAllContacts/getContactById (status.md gap 4) via the WinRT
ContactStore (cn1_windows_winrt.cpp, same CN1_HAVE_WINRT gate). One native call
returns every contact as a delimited blob (id/name/phone/email, read via the base
IContact + versioned IContact2/IContactManagerStatics2 interfaces) 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),
never fabricated. Compiles on the Windows ARM64 VM via the proven WRL await
pattern.

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

Author: shai-almog

Ports/WindowsPort/nativeSources/cn1_windows_winrt.cpp

@@ -43,16 +43,21 @@
 #ifdef CN1_HAVE_WINRT
 
 #include <roapi.h>
+#include <string>
 #include <wrl.h>
 #include <wrl/event.h>
 #include <wrl/wrappers/corewrappers.h>
 #include <windows.foundation.h>
+#include <windows.foundation.collections.h>
 #include <windows.security.credentials.ui.h>
 #include <windows.devices.geolocation.h>
+#include <windows.applicationmodel.contacts.h>
 
 using namespace ABI::Windows::Foundation;
+using namespace ABI::Windows::Foundation::Collections;
 using namespace ABI::Windows::Security::Credentials::UI;
 using namespace ABI::Windows::Devices::Geolocation;
+using namespace ABI::Windows::ApplicationModel::Contacts;
 using namespace Microsoft::WRL;
 using namespace Microsoft::WRL::Wrappers;
 
@@ -94,6 +99,22 @@ static void cn1WinRtInit() {
     RoInitialize(RO_INIT_MULTITHREADED);
 }
 
+/* Appends the UTF-8 bytes of an HSTRING to `out` (empty HSTRING -> nothing). */
+static void cn1AppendHString(std::string& out, HSTRING h) {
+    UINT32 len = 0;
+    PCWSTR w = WindowsGetStringRawBuffer(h, &len);
+    if (w == NULL || len == 0) {
+        return;
+    }
+    int n = WideCharToMultiByte(CP_UTF8, 0, w, (int) len, NULL, 0, NULL, NULL);
+    if (n <= 0) {
+        return;
+    }
+    size_t at = out.size();
+    out.resize(at + (size_t) n);
+    WideCharToMultiByte(CP_UTF8, 0, w, (int) len, &out[at], n, NULL, NULL);
+}
+
 #endif /* CN1_HAVE_WINRT */
 
 extern "C" {
@@ -243,6 +264,103 @@ JAVA_BOOLEAN com_codename1_impl_windows_WindowsNative_locationGetCurrent___doubl
 #endif
 }
 
+/* -------------------------------------------------------------- contacts
+ *
+ * Reads the user's contacts via the WinRT ContactStore and returns them as a
+ * 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. */
+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(
+            HStringReference(RuntimeClass_Windows_ApplicationModel_Contacts_ContactManager).Get(),
+            IID_PPV_ARGS(&statics)))) {
+        return JAVA_NULL;
+    }
+    ComPtr<IAsyncOperation<ContactStore*>> storeOp;
+    if (FAILED(statics->RequestStoreAsync(&storeOp))) {
+        return JAVA_NULL;
+    }
+    ComPtr<IContactStore> store;
+    if (FAILED(cn1AwaitOp(storeOp.Get(), store.GetAddressOf())) || !store) {
+        return JAVA_NULL;
+    }
+    ComPtr<IAsyncOperation<IVectorView<Contact*>*>> findOp;
+    if (FAILED(store->FindContactsAsync(&findOp))) {
+        return JAVA_NULL;
+    }
+    ComPtr<IVectorView<Contact*>> contacts;
+    if (FAILED(cn1AwaitOp(findOp.Get(), contacts.GetAddressOf())) || !contacts) {
+        return JAVA_NULL;
+    }
+    unsigned int size = 0;
+    contacts->get_Size(&size);
+    std::string blob;
+    for (unsigned int i = 0; i < size; i++) {
+        ComPtr<IContact> c;
+        if (FAILED(contacts->GetAt(i, &c)) || !c) {
+            continue;
+        }
+        if (i > 0) {
+            blob.push_back('\x1e');
+        }
+        /* Name is on the base IContact; Id / Phones / Emails on IContact2. */
+        HString name;
+        c->get_Name(name.GetAddressOf());
+        ComPtr<IContact2> c2;
+        c.As(&c2);
+        HString id;
+        if (c2) {
+            c2->get_Id(id.GetAddressOf());
+        }
+        cn1AppendHString(blob, id.Get());
+        blob.push_back('\x1f');
+        cn1AppendHString(blob, name.Get());
+        blob.push_back('\x1f');
+        /* first phone number */
+        if (c2) {
+            ComPtr<IVector<ContactPhone*>> phones;
+            if (SUCCEEDED(c2->get_Phones(&phones)) && phones) {
+                unsigned int pn = 0;
+                phones->get_Size(&pn);
+                if (pn > 0) {
+                    ComPtr<IContactPhone> phone;
+                    if (SUCCEEDED(phones->GetAt(0, &phone)) && phone) {
+                        HString num;
+                        phone->get_Number(num.GetAddressOf());
+                        cn1AppendHString(blob, num.Get());
+                    }
+                }
+            }
+        }
+        blob.push_back('\x1f');
+        /* first email */
+        if (c2) {
+            ComPtr<IVector<ContactEmail*>> emails;
+            if (SUCCEEDED(c2->get_Emails(&emails)) && emails) {
+                unsigned int en = 0;
+                emails->get_Size(&en);
+                if (en > 0) {
+                    ComPtr<IContactEmail> email;
+                    if (SUCCEEDED(emails->GetAt(0, &email)) && email) {
+                        HString addr;
+                        email->get_Address(addr.GetAddressOf());
+                        cn1AppendHString(blob, addr.Get());
+                    }
+                }
+            }
+        }
+    }
+    return newStringFromCString(threadStateData, blob.c_str());
+#else
+    return JAVA_NULL;
+#endif
+}
+
 } /* extern "C" */
 
 #endif /* _WIN32 */

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

@@ -371,6 +371,69 @@ public com.codename1.location.LocationManager getLocationManager() {
         return locationManager;
     }
 
+    /* ------------------------------------------------------------ contacts
+     * Backed by the WinRT ContactStore (cn1_windows_winrt.cpp). One native call
+     * returns every contact as a delimited blob which is parsed and briefly
+     * cached here so getAllContacts() + the per-id getContactById() the base
+     * runs in a loop share a single store read. */
+    private java.util.HashMap<String, String[]> contactCache;
+
+    private java.util.HashMap<String, String[]> contacts() {
+        if (contactCache == null) {
+            contactCache = new java.util.HashMap<String, String[]>();
+            String blob = WindowsNative.contactsGetAll();
+            if (blob != null && blob.length() > 0) {
+                String[] records = blob.split("");
+                for (int i = 0; i < records.length; i++) {
+                    String[] f = records[i].split("", -1);
+                    if (f.length >= 1 && f[0].length() > 0) {
+                        contactCache.put(f[0], f);
+                    }
+                }
+            }
+        }
+        return contactCache;
+    }
+
+    @Override
+    public String[] getAllContacts(boolean withNumbers) {
+        java.util.HashMap<String, String[]> all = contacts();
+        java.util.ArrayList<String> ids = new java.util.ArrayList<String>();
+        for (String[] f : all.values()) {
+            // withNumbers filters to contacts that have a phone number.
+            if (!withNumbers || (f.length > 2 && f[2].length() > 0)) {
+                ids.add(f[0]);
+            }
+        }
+        return ids.toArray(new String[ids.size()]);
+    }
+
+    @Override
+    public com.codename1.contacts.Contact getContactById(String id) {
+        String[] f = contacts().get(id);
+        if (f == null) {
+            return null;
+        }
+        com.codename1.contacts.Contact c = new com.codename1.contacts.Contact();
+        c.setId(f[0]);
+        if (f.length > 1) {
+            c.setDisplayName(f[1]);
+        }
+        if (f.length > 2 && f[2].length() > 0) {
+            c.setPrimaryPhoneNumber(f[2]);
+            java.util.Hashtable phones = new java.util.Hashtable();
+            phones.put("mobile", f[2]);
+            c.setPhoneNumbers(phones);
+        }
+        if (f.length > 3 && f[3].length() > 0) {
+            c.setPrimaryEmail(f[3]);
+            java.util.Hashtable emails = new java.util.Hashtable();
+            emails.put("home", f[3]);
+            c.setEmails(emails);
+        }
+        return c;
+    }
+
     @Override
     public int getDisplayWidth() {
         return WindowsNative.getDisplayWidth();

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

@@ -529,6 +529,17 @@ public static native long editStringAt(int x, int y, int w, int h, String text,
      */
     public static native boolean locationGetCurrent(double[] out);
 
+    /* -------------------------------------------------- contacts (WinRT) */
+
+    /**
+     * Reads the user's contacts via the WinRT {@code ContactStore} and returns
+     * them as a single blob: records separated by {@code 0x1E}, fields (id, name,
+     * phone, email) by {@code 0x1F}. {@code null} when the store is inaccessible
+     * (no WinRT / access denied); empty string when there are simply no contacts.
+     * Blocks (call off the EDT).
+     */
+    public static native String contactsGetAll();
+
     // ---------------------------------------------------------------------
     // 3D / Direct3D 11 backend (com.codename1.gpu). Implemented in
     // nativeSources/cn1_windows_d3d.cpp. Every peer is an opaque long (a D3D

Ports/WindowsPort/status.md

@@ -150,7 +150,15 @@ they stay honest until backed by a real implementation:
 - Push + local notifications (`sendLocalNotification`)
 - Vibrate (no desktop vibration motor)
 - System share, print
-- Contacts (WinRT — pending)
+
+**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
+(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.
+Compiles on the Windows ARM64 VM via the same proven WRL await pattern as
+biometric/location.
 
 **Location / GPS — implemented (WinRT).** `getLocationManager()` →
 `WindowsLocationManager`, backed by the WinRT `Geolocator`