@livx.cc/appwrap 0.47.3 → 0.48.1

package/runtime/modules-native/widget/App_Resources/Android/src/main/java/cc/livx/appwrap/AppwrapWidgetProvider.kt

@@ -0,0 +1,79 @@
+package cc.livx.appwrap
+
+import android.app.PendingIntent
+import android.appwidget.AppWidgetManager
+import android.appwidget.AppWidgetProvider
+import android.content.Context
+import android.content.Intent
+import android.graphics.BitmapFactory
+import android.net.Uri
+import android.view.View
+import android.widget.RemoteViews
+import org.json.JSONObject
+import java.io.File
+
+/**
+ * Home-screen launcher widget (Android parity of the iOS WidgetKit launcher). Reads the payload the
+ * `widget.publish` handler wrote into SharedPreferences ("appwrap.widget" / key "appwrap.widget") and
+ * renders up to 4 icon-grid tiles; each tile deep-links back into the app via its entry's URL. Icons
+ * are PNGs the handler saved into the app files dir. Resource ids are looked up by name so the module
+ * needs no compile-time reference to the host app's R class.
+ */
+class AppwrapWidgetProvider : AppWidgetProvider() {
+    private val tiles = listOf("tile0", "tile1", "tile2", "tile3")
+
+    override fun onUpdate(ctx: Context, mgr: AppWidgetManager, ids: IntArray) {
+        for (id in ids) render(ctx, mgr, id)
+    }
+
+    private fun res(ctx: Context, type: String, name: String) =
+        ctx.resources.getIdentifier(name, type, ctx.packageName)
+
+    private fun render(ctx: Context, mgr: AppWidgetManager, id: Int) {
+        val rv = RemoteViews(ctx.packageName, res(ctx, "layout", "appwrap_widget"))
+        val raw = ctx.getSharedPreferences("appwrap.widget", Context.MODE_PRIVATE)
+            .getString("appwrap.widget", null)
+        val payload = raw?.let { runCatching { JSONObject(it) }.getOrNull() }
+        val title = payload?.optString("title") ?: ""
+        rv.setTextViewText(res(ctx, "id", "appwrap_widget_title"), title)
+        rv.setViewVisibility(res(ctx, "id", "appwrap_widget_title"),
+            if (title.isEmpty()) View.GONE else View.VISIBLE)
+        val entries = payload?.optJSONArray("entries")
+
+        for (i in tiles.indices) {
+            val tileId = res(ctx, "id", tiles[i])
+            val e = if (entries != null && i < entries.length()) entries.optJSONObject(i) else null
+            if (e == null) { rv.setViewVisibility(tileId, View.INVISIBLE); continue }
+            rv.setViewVisibility(tileId, View.VISIBLE)
+            rv.setTextViewText(res(ctx, "id", "${tiles[i]}_label"), e.optString("label"))
+            // unread-count badge on the icon's top-right corner (absent/0 → hidden)
+            val badgeId = res(ctx, "id", "${tiles[i]}_badge")
+            val badge = e.optInt("badge", 0)
+            if (badge > 0) {
+                rv.setTextViewText(badgeId, if (badge > 99) "99+" else badge.toString())
+                rv.setViewVisibility(badgeId, View.VISIBLE)
+            } else rv.setViewVisibility(badgeId, View.GONE)
+            val icon = e.optString("icon", "")
+            if (icon.isNotEmpty()) {
+                val f = File(ctx.filesDir, icon)
+                if (f.exists()) BitmapFactory.decodeFile(f.absolutePath)
+                    ?.let { rv.setImageViewBitmap(res(ctx, "id", "${tiles[i]}_icon"), it) }
+            }
+            val link = e.optString("deepLink", "")
+            if (link.isNotEmpty()) {
+                // Target the app's OWN launch activity explicitly + carry the deep link as data — the
+                // shell reads intent.getData() (like a pinned shortcut). Relying on an ACTION_VIEW
+                // intent-filter match would need an App Links autoVerify filter for https hosts, which
+                // the shell doesn't declare; an explicit component always opens the app.
+                val intent = (ctx.packageManager.getLaunchIntentForPackage(ctx.packageName)
+                    ?: Intent(Intent.ACTION_VIEW).setPackage(ctx.packageName))
+                    .setAction(Intent.ACTION_VIEW)
+                    .setData(Uri.parse(link))
+                    .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+                val flags = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+                rv.setOnClickPendingIntent(tileId, PendingIntent.getActivity(ctx, i, intent, flags))
+            }
+        }
+        mgr.updateAppWidget(id, rv)
+    }
+}

package/runtime/modules-native/widget/App_Resources/Android/src/main/res/drawable/appwrap_badge_bg.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Red pill background for the widget tile's unread-count badge. -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
+    <solid android:color="#FF3B30" />
+    <stroke android:width="1.5dp" android:color="#FFFFFF" />
+    <corners android:radius="9dp" />
+</shape>

package/runtime/modules-native/widget/App_Resources/Android/src/main/res/layout/appwrap_widget.xml

@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- AppWrap launcher widget: title + a 2×2 icon-grid of deep-linked tiles. Populated by
+     AppwrapWidgetProvider from the published payload; empty tiles are set INVISIBLE. Each icon can
+     carry an unread-count badge (tileN_badge) overlaid on its top-right corner. -->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    android:background="#F2FFFFFF"
+    android:padding="10dp">
+
+    <TextView
+        android:id="@+id/appwrap_widget_title"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textColor="#222222"
+        android:textStyle="bold"
+        android:textSize="12sp"
+        android:layout_marginBottom="6dp"
+        android:maxLines="1"
+        android:ellipsize="end" />
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1"
+        android:orientation="horizontal"
+        android:weightSum="2">
+
+        <LinearLayout android:id="@+id/tile0" style="@style/AppwrapWidgetTile">
+            <FrameLayout android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginBottom="4dp">
+                <ImageView android:id="@+id/tile0_icon" style="@style/AppwrapWidgetIcon" />
+                <TextView android:id="@+id/tile0_badge" style="@style/AppwrapWidgetBadge" android:visibility="gone" />
+            </FrameLayout>
+            <TextView android:id="@+id/tile0_label" style="@style/AppwrapWidgetLabel" />
+        </LinearLayout>
+
+        <LinearLayout android:id="@+id/tile1" style="@style/AppwrapWidgetTile">
+            <FrameLayout android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginBottom="4dp">
+                <ImageView android:id="@+id/tile1_icon" style="@style/AppwrapWidgetIcon" />
+                <TextView android:id="@+id/tile1_badge" style="@style/AppwrapWidgetBadge" android:visibility="gone" />
+            </FrameLayout>
+            <TextView android:id="@+id/tile1_label" style="@style/AppwrapWidgetLabel" />
+        </LinearLayout>
+    </LinearLayout>
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1"
+        android:orientation="horizontal"
+        android:weightSum="2">
+
+        <LinearLayout android:id="@+id/tile2" style="@style/AppwrapWidgetTile">
+            <FrameLayout android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginBottom="4dp">
+                <ImageView android:id="@+id/tile2_icon" style="@style/AppwrapWidgetIcon" />
+                <TextView android:id="@+id/tile2_badge" style="@style/AppwrapWidgetBadge" android:visibility="gone" />
+            </FrameLayout>
+            <TextView android:id="@+id/tile2_label" style="@style/AppwrapWidgetLabel" />
+        </LinearLayout>
+
+        <LinearLayout android:id="@+id/tile3" style="@style/AppwrapWidgetTile">
+            <FrameLayout android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginBottom="4dp">
+                <ImageView android:id="@+id/tile3_icon" style="@style/AppwrapWidgetIcon" />
+                <TextView android:id="@+id/tile3_badge" style="@style/AppwrapWidgetBadge" android:visibility="gone" />
+            </FrameLayout>
+            <TextView android:id="@+id/tile3_label" style="@style/AppwrapWidgetLabel" />
+        </LinearLayout>
+    </LinearLayout>
+</LinearLayout>

package/runtime/modules-native/widget/App_Resources/Android/src/main/res/values/appwrap_widget_styles.xml

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- One icon-grid tile: a centered icon over a single-line label, equal-weight in its row. -->
+    <style name="AppwrapWidgetTile">
+        <item name="android:layout_width">0dp</item>
+        <item name="android:layout_height">match_parent</item>
+        <item name="android:layout_weight">1</item>
+        <item name="android:orientation">vertical</item>
+        <item name="android:gravity">center</item>
+        <item name="android:padding">4dp</item>
+    </style>
+    <style name="AppwrapWidgetIcon">
+        <item name="android:layout_width">36dp</item>
+        <item name="android:layout_height">36dp</item>
+        <item name="android:scaleType">fitCenter</item>
+    </style>
+    <!-- Unread-count bubble overlaid on the icon's top-right corner. -->
+    <style name="AppwrapWidgetBadge">
+        <item name="android:layout_width">wrap_content</item>
+        <item name="android:layout_height">18dp</item>
+        <item name="android:layout_gravity">top|end</item>
+        <item name="android:minWidth">18dp</item>
+        <item name="android:paddingLeft">5dp</item>
+        <item name="android:paddingRight">5dp</item>
+        <item name="android:background">@drawable/appwrap_badge_bg</item>
+        <item name="android:gravity">center</item>
+        <item name="android:textColor">#FFFFFF</item>
+        <item name="android:textStyle">bold</item>
+        <item name="android:textSize">10sp</item>
+        <item name="android:includeFontPadding">false</item>
+    </style>
+    <style name="AppwrapWidgetLabel">
+        <item name="android:layout_width">wrap_content</item>
+        <item name="android:layout_height">wrap_content</item>
+        <item name="android:textColor">#333333</item>
+        <item name="android:textSize">11sp</item>
+        <item name="android:maxLines">1</item>
+        <item name="android:ellipsize">end</item>
+    </style>
+</resources>

package/runtime/modules-native/widget/App_Resources/Android/src/main/res/xml/appwrap_widget_info.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Launcher widget: ~4×2 cells (medium), resizable, initial layout = the icon-grid. updatePeriodMillis
+     0 → the app drives refreshes itself via widget.publish (AppWidgetManager broadcast). -->
+<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
+    android:minWidth="250dp"
+    android:minHeight="110dp"
+    android:targetCellWidth="4"
+    android:targetCellHeight="2"
+    android:updatePeriodMillis="0"
+    android:initialLayout="@layout/appwrap_widget"
+    android:resizeMode="horizontal|vertical"
+    android:widgetCategory="home_screen"
+    android:previewLayout="@layout/appwrap_widget" />

package/runtime/modules-native/widget/App_Resources/iOS/extensions/AppwrapWidget/AppwrapWidget.entitlements

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>com.apple.security.application-groups</key>
+  <array>
+    <string>__APP_GROUP__</string>
+  </array>
+</dict>
+</plist>

package/runtime/modules-native/widget/App_Resources/iOS/extensions/AppwrapWidget/AppwrapWidget.swift

@@ -0,0 +1,275 @@
+import WidgetKit
+import SwiftUI
+import UIKit
+
+// ── AppWrap home-screen widget ──────────────────────────────────────────────
+// Data-driven: the app publishes a small JSON payload into the App Group container (via the
+// `widget.publish` native handler); this extension reads it at render and draws one of three
+// templates. Each tile/row carries its own deep link (a full URL the app's deep-link routing maps to
+// a screen). No app-specific values are hardcoded — the App Group id is templated in by the CLI.
+
+private let appGroup = "__APP_GROUP__"          // stamped by the CLI → group.<appId>
+private let launcherKey = "appwrap.widget"       // launcher (icon-grid) payload key
+private let dataKey = "appwrap.widget.data"       // data widget (stat/list) payload key
+
+// ── Payload model (mirrors the widget.publish contract) ──
+struct WidgetEntry: Decodable {
+    let label: String
+    var sublabel: String?
+    var deepLink: String?
+    var icon: String?      // filename of a PNG the handler saved into the App Group container
+    var badge: Int?        // unread/attention count drawn as a bubble on the tile (absent/0 = none)
+}
+struct WidgetStat: Decodable {
+    let value: String
+    var label: String?
+    var sublabel: String?
+}
+struct WidgetPayload: Decodable {
+    let template: String            // "icon-grid" | "stat" | "list"
+    var title: String?
+    var entries: [WidgetEntry]?
+    var stat: WidgetStat?
+    var deepLink: String?           // whole-widget link (stat template / fallback)
+}
+
+private func loadPayload(_ key: String) -> WidgetPayload? {
+    guard let raw = UserDefaults(suiteName: appGroup)?.string(forKey: key),
+          let data = raw.data(using: .utf8) else { return nil }
+    return try? JSONDecoder().decode(WidgetPayload.self, from: data)
+}
+
+private func containerImage(_ name: String?) -> UIImage? {
+    guard let name, !name.isEmpty,
+          let dir = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: appGroup)
+    else { return nil }
+    return UIImage(contentsOfFile: dir.appendingPathComponent(name).path)
+}
+
+// ── Timeline ──
+struct Entry: TimelineEntry {
+    let date: Date
+    let payload: WidgetPayload?
+}
+struct Provider: TimelineProvider {
+    let key: String
+    func placeholder(in context: Context) -> Entry { Entry(date: Date(), payload: nil) }
+    func getSnapshot(in context: Context, completion: @escaping (Entry) -> Void) {
+        completion(Entry(date: Date(), payload: loadPayload(key)))
+    }
+    func getTimeline(in context: Context, completion: @escaping (Timeline<Entry>) -> Void) {
+        completion(Timeline(entries: [Entry(date: Date(), payload: loadPayload(key))], policy: .never))
+    }
+}
+
+// ── Tile / row views ──
+private struct TileView: View {
+    @Environment(\.widgetFamily) private var family
+    let entry: WidgetEntry
+    private var iconSize: CGFloat { family == .systemLarge ? 60 : 52 }
+
+    var body: some View {
+        let inner = VStack(spacing: 6) {
+            icon
+            Text(entry.label)
+                .font(.system(size: 12, weight: .medium))
+                .foregroundStyle(.primary)
+                .lineLimit(1).minimumScaleFactor(0.8)
+        }
+        .frame(maxWidth: .infinity)
+        .contentShape(Rectangle()) // whole tile is the hit target — ambiguous taps otherwise route wrong
+        if let link = entry.deepLink, let url = URL(string: link) {
+            Link(destination: url) { inner }.tint(.primary)
+        } else { inner }
+    }
+
+    @ViewBuilder private var icon: some View {
+        let shape = RoundedRectangle(cornerRadius: iconSize * 0.25, style: .continuous)
+        Group {
+            if let img = containerImage(entry.icon) {
+                Image(uiImage: img).resizable().scaledToFill()
+            } else {
+                shape.fill(LinearGradient(colors: [Color.gray.opacity(0.55), Color.gray.opacity(0.35)],
+                                          startPoint: .top, endPoint: .bottom))
+                    .overlay(Text(String(entry.label.prefix(1)).uppercased())
+                        .font(.system(size: 22, weight: .semibold)).foregroundStyle(.white))
+            }
+        }
+        .frame(width: iconSize, height: iconSize)
+        .clipShape(shape)
+        .overlay(shape.strokeBorder(.white.opacity(0.14), lineWidth: 0.5))
+        .shadow(color: .black.opacity(0.18), radius: 3, x: 0, y: 1)
+        .overlay(alignment: .topTrailing) { badge } // iOS-style unread bubble, overhangs the icon corner
+    }
+
+    @ViewBuilder private var badge: some View {
+        if let n = entry.badge, n > 0 {
+            Text(n > 99 ? "99+" : "\(n)")
+                .font(.system(size: 11, weight: .bold))
+                .foregroundStyle(.white)
+                .padding(.horizontal, 5).frame(minWidth: 18, minHeight: 18)
+                .background(Color.red, in: Capsule())
+                .overlay(Capsule().strokeBorder(.white, lineWidth: 1.5))
+                .offset(x: 6, y: -6)
+        }
+    }
+}
+
+private struct RowView: View {
+    let entry: WidgetEntry
+    var body: some View {
+        let inner = HStack(spacing: 10) {
+            if let img = containerImage(entry.icon) {
+                Image(uiImage: img).resizable().aspectRatio(contentMode: .fit).frame(width: 26, height: 26).clipShape(RoundedRectangle(cornerRadius: 6))
+            }
+            VStack(alignment: .leading, spacing: 1) {
+                Text(entry.label).font(.caption).bold().lineLimit(1)
+                if let s = entry.sublabel { Text(s).font(.caption2).foregroundStyle(.secondary).lineLimit(1) }
+            }
+            Spacer(minLength: 0)
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        if let link = entry.deepLink, let url = URL(string: link) {
+            Link(destination: url) { inner }
+        } else { inner }
+    }
+}
+
+// ── Root view — routes on template + family ──
+struct AppwrapWidgetEntryView: View {
+    @Environment(\.widgetFamily) private var family
+    var entry: Provider.Entry
+
+    var body: some View {
+        content.containerBackgroundCompat()
+    }
+
+    @ViewBuilder private var content: some View {
+        if let p = entry.payload {
+            switch p.template {
+            case "stat":      statView(p)
+            case "list":      listView(p)
+            default:          gridView(p) // "icon-grid"
+            }
+        } else {
+            emptyView
+        }
+    }
+
+    private var columns: Int { family == .systemSmall ? 2 : 4 }
+    private var maxTiles: Int { family == .systemLarge ? 12 : (family == .systemSmall ? 4 : 4) }
+    private var maxRows: Int { family == .systemLarge ? 6 : 3 }
+
+    @ViewBuilder private func header(_ p: WidgetPayload) -> some View {
+        HStack(spacing: 6) {
+            Text(p.title ?? "My Apps").font(.system(size: 15, weight: .semibold))
+            Spacer(minLength: 0)
+            // the grid glyph opens the app's "My Apps" drawer (payload.deepLink carries the menu link)
+            let glyph = Image(systemName: "square.grid.2x2.fill")
+                .font(.system(size: 13, weight: .semibold)).foregroundStyle(.secondary)
+            if let link = p.deepLink, let url = URL(string: link) {
+                Link(destination: url) { glyph.padding(6).contentShape(Rectangle()) }.tint(.secondary)
+            } else { glyph }
+        }
+    }
+
+    @ViewBuilder private func gridView(_ p: WidgetPayload) -> some View {
+        let items = Array((p.entries ?? []).prefix(maxTiles))
+        VStack(alignment: .leading, spacing: family == .systemSmall ? 10 : 14) {
+            if family != .systemSmall { header(p) }
+            if items.isEmpty {
+                Spacer()
+                Text("Pin apps in Blank to see them here")
+                    .font(.footnote).foregroundStyle(.secondary).frame(maxWidth: .infinity, alignment: .center)
+                Spacer()
+            } else {
+                // Native Grid (iOS 16+, the extension's target): a short final row aligns into the
+                // leading columns automatically, rows are content-height (no greedy filler), and per-tile
+                // Links keep distinct hit targets (a LazyVGrid would route every tap to the first link).
+                let chunks = stride(from: 0, to: items.count, by: columns).map { Array(items[$0 ..< min($0 + columns, items.count)]) }
+                Grid(alignment: .top, horizontalSpacing: 8, verticalSpacing: family == .systemLarge ? 16 : 12) {
+                    ForEach(chunks.indices, id: \.self) { r in
+                        GridRow {
+                            ForEach(chunks[r].indices, id: \.self) { c in TileView(entry: chunks[r][c]) }
+                        }
+                    }
+                }
+                Spacer(minLength: 0) // top-align the grid (app-folder feel), no floating gap
+            }
+        }
+    }
+
+    @ViewBuilder private func listView(_ p: WidgetPayload) -> some View {
+        let items = Array((p.entries ?? []).prefix(maxRows))
+        VStack(alignment: .leading, spacing: 8) {
+            if let t = p.title { Text(t).font(.caption).bold() }
+            ForEach(items.indices, id: \.self) { RowView(entry: items[$0]) }
+            Spacer(minLength: 0)
+        }
+    }
+
+    @ViewBuilder private func statView(_ p: WidgetPayload) -> some View {
+        let inner = VStack(alignment: .leading, spacing: 2) {
+            if let t = p.title { Text(t).font(.caption2).foregroundStyle(.secondary).lineLimit(1) }
+            Spacer(minLength: 0)
+            Text(p.stat?.value ?? "—").font(.system(size: 40, weight: .bold, design: .rounded)).minimumScaleFactor(0.5).lineLimit(1)
+            if let l = p.stat?.label { Text(l).font(.caption).bold().lineLimit(1) }
+            if let s = p.stat?.sublabel { Text(s).font(.caption2).foregroundStyle(.secondary).lineLimit(1) }
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .leading)
+        if let link = p.deepLink, let url = URL(string: link) { Link(destination: url) { inner } } else { inner }
+    }
+
+    private var emptyView: some View {
+        VStack(spacing: 6) {
+            Image(systemName: "square.grid.2x2.fill").font(.title)
+            Text("Open App").font(.caption).bold()
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .widgetURL(entry.payload?.deepLink.flatMap { URL(string: $0) })
+    }
+}
+
+private extension View {
+    // iOS 17+ requires an explicit container background for Home Screen widgets; older builds pad+fill.
+    @ViewBuilder func containerBackgroundCompat() -> some View {
+        if #available(iOS 17.0, *) {
+            self.padding(12).containerBackground(.fill.tertiary, for: .widget)
+        } else {
+            self.padding(12).background(Color(white: 0.96))
+        }
+    }
+}
+
+// Two distinct kinds so a mini-app's data widget never clobbers the launcher (each reads its own key).
+struct AppwrapLauncherWidget: Widget {
+    let kind = "AppwrapLauncher"
+    var body: some WidgetConfiguration {
+        StaticConfiguration(kind: kind, provider: Provider(key: launcherKey)) { entry in
+            AppwrapWidgetEntryView(entry: entry)
+        }
+        .configurationDisplayName("AppWrap")
+        .description("Your pinned apps.")
+        .supportedFamilies([.systemSmall, .systemMedium, .systemLarge])
+    }
+}
+
+struct AppwrapDataWidget: Widget {
+    let kind = "AppwrapData"
+    var body: some WidgetConfiguration {
+        StaticConfiguration(kind: kind, provider: Provider(key: dataKey)) { entry in
+            AppwrapWidgetEntryView(entry: entry)
+        }
+        .configurationDisplayName("AppWrap Data")
+        .description("Live stats from an app.")
+        .supportedFamilies([.systemSmall, .systemMedium, .systemLarge])
+    }
+}
+
+@main
+struct AppwrapWidgetBundle: WidgetBundle {
+    var body: some Widget {
+        AppwrapLauncherWidget()
+        AppwrapDataWidget()
+    }
+}

package/runtime/modules-native/widget/App_Resources/iOS/extensions/AppwrapWidget/Info.plist

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDisplayName</key>
+  <string>AppWrap</string>
+  <key>CFBundleName</key>
+  <string>AppwrapWidget</string>
+  <key>CFBundleIdentifier</key>
+  <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+  <key>CFBundleExecutable</key>
+  <string>$(EXECUTABLE_NAME)</string>
+  <key>CFBundlePackageType</key>
+  <string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0</string>
+  <key>CFBundleVersion</key>
+  <string>1</string>
+  <key>NSExtension</key>
+  <dict>
+    <key>NSExtensionPointIdentifier</key>
+    <string>com.apple.widgetkit-extension</string>
+  </dict>
+</dict>
+</plist>

package/runtime/modules-native/widget/App_Resources/iOS/extensions/AppwrapWidget/extension.json

@@ -0,0 +1,9 @@
+{
+  "frameworks": ["WidgetKit", "SwiftUI"],
+  "targetBuildConfigurationProperties": {
+    "IPHONEOS_DEPLOYMENT_TARGET": "16.0",
+    "SWIFT_VERSION": "5.0",
+    "CODE_SIGN_ENTITLEMENTS": "../../App_Resources/iOS/extensions/AppwrapWidget/AppwrapWidget.entitlements",
+    "INFOPLIST_FILE": "../../App_Resources/iOS/extensions/AppwrapWidget/Info.plist"
+  }
+}

package/runtime/modules-native/widget/App_Resources/iOS/src/AppwrapWidgetReload.swift

@@ -0,0 +1,18 @@
+import Foundation
+import WidgetKit
+
+// WidgetKit's `WidgetCenter.shared.reloadAllTimelines()` is Swift-only — it has NO Objective-C API, so
+// NativeScript's ObjC bridge can't call it directly (a JS `WidgetCenter.sharedCenter…` is a silent
+// no-op). This @objc shim bridges it so the widget.publish handler can force a refresh after writing
+// the App Group payload — otherwise a PLACED widget keeps its stale (empty) timeline (policy .never)
+// while only the gallery preview re-snapshots live. Shipped via the widget module's nativeSrc →
+// compiled into the app (and links WidgetKit into the main target) only when `widget` is active.
+@objc(AppwrapWidgetReload)
+public class AppwrapWidgetReload: NSObject {
+    /// Reload every timeline of every kind (launcher + data). iOS 14+.
+    @objc public static func reloadAll() {
+        if #available(iOS 14.0, *) {
+            WidgetCenter.shared.reloadAllTimelines()
+        }
+    }
+}

package/runtime/references.d.ts

@@ -23,3 +23,4 @@
 /// <reference path="./node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!Photos.d.ts" />
 /// <reference path="./node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!AppTrackingTransparency.d.ts" />
 /// <reference path="./node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!AdSupport.d.ts" />
+/// <reference path="./node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!Intents.d.ts" />

package/runtime/tests/notif-identity.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from 'bun:test';
+import { notifIdentity } from '../app/shell/notif-identity';
+
+describe('notifIdentity', () => {
+  test('no sender/icon → plain, identity not used', () => {
+    const r = notifIdentity({ title: 'Reminder', body: 'Hi' });
+    expect(r).toEqual({
+      title: 'Reminder', subtitle: '', body: 'Hi',
+      senderName: '', iconUrl: '', useIdentity: false,
+    });
+  });
+
+  test('sender named → sender becomes title, original demoted to subtitle', () => {
+    const r = notifIdentity({ title: 'You won!', body: 'Tap', sender: 'Coin Flip', icon: 'https://x/i.png' });
+    expect(r.title).toBe('Coin Flip');
+    expect(r.subtitle).toBe('You won!');
+    expect(r.senderName).toBe('Coin Flip');
+    expect(r.iconUrl).toBe('https://x/i.png');
+    expect(r.useIdentity).toBe(true);
+  });
+
+  test('subtitle dropped when title duplicates the sender', () => {
+    const r = notifIdentity({ title: 'Coin Flip', sender: 'Coin Flip' });
+    expect(r.title).toBe('Coin Flip');
+    expect(r.subtitle).toBe('');
+  });
+
+  test('icon only (no sender) → identity used, title kept, no subtitle', () => {
+    const r = notifIdentity({ title: 'Ping', icon: 'data:image/png;base64,AAAA' });
+    expect(r.title).toBe('Ping');
+    expect(r.subtitle).toBe('');
+    expect(r.senderName).toBe('');
+    expect(r.iconUrl).toBe('data:image/png;base64,AAAA');
+    expect(r.useIdentity).toBe(true);
+  });
+
+  test('missing title/body coerce to empty strings', () => {
+    const r = notifIdentity({});
+    expect(r.title).toBe('');
+    expect(r.body).toBe('');
+    expect(r.useIdentity).toBe(false);
+  });
+});