palmier 0.7.2 → 0.7.4

package/palmier-server/pwa/src/components/HostMenu.tsx

@@ -15,9 +15,74 @@ interface LocationPermissionPlugin {
   check(): Promise<LocationPermissionResult>;
 }
 
+interface NotificationListenerResult {
+  enabled: boolean;
+}
+
+interface NotificationListenerPlugin {
+  request(): Promise<NotificationListenerResult>;
+  check(): Promise<NotificationListenerResult>;
+}
+
 const LocationPermission = Capacitor.isNativePlatform()
   ? registerPlugin<LocationPermissionPlugin>("LocationPermission")
   : null;
+
+interface SmsPermissionResult {
+  granted: boolean;
+}
+
+interface SmsPermissionPlugin {
+  request(): Promise<SmsPermissionResult>;
+  check(): Promise<SmsPermissionResult>;
+}
+
+interface ContactsPermissionResult {
+  granted: boolean;
+}
+
+interface ContactsPermissionPlugin {
+  request(): Promise<ContactsPermissionResult>;
+  check(): Promise<ContactsPermissionResult>;
+}
+
+interface CalendarPermissionResult {
+  granted: boolean;
+}
+
+interface CalendarPermissionPlugin {
+  request(): Promise<CalendarPermissionResult>;
+  check(): Promise<CalendarPermissionResult>;
+}
+
+interface DndAccessResult {
+  enabled: boolean;
+}
+
+interface DndAccessPlugin {
+  request(): Promise<DndAccessResult>;
+  check(): Promise<DndAccessResult>;
+}
+
+const NotificationListener = Capacitor.isNativePlatform()
+  ? registerPlugin<NotificationListenerPlugin>("NotificationListener")
+  : null;
+
+const SmsPermission = Capacitor.isNativePlatform()
+  ? registerPlugin<SmsPermissionPlugin>("SmsPermission")
+  : null;
+
+const ContactsPermission = Capacitor.isNativePlatform()
+  ? registerPlugin<ContactsPermissionPlugin>("ContactsPermission")
+  : null;
+
+const CalendarPermission = Capacitor.isNativePlatform()
+  ? registerPlugin<CalendarPermissionPlugin>("CalendarPermission")
+  : null;
+
+const DndAccess = Capacitor.isNativePlatform()
+  ? registerPlugin<DndAccessPlugin>("DndAccess")
+  : null;
 import { useHostStore } from "../contexts/HostStoreContext";
 import { useMediaQuery } from "../hooks/useMediaQuery";
 
@@ -44,6 +109,20 @@ export default function HostMenu({ daemonVersion, locationClientToken, activeCli
   const [renameValue, setRenameValue] = useState("");
   const [confirmingDeleteId, setConfirmingDeleteId] = useState<string | null>(null);
   const [togglingLocation, setTogglingLocation] = useState(false);
+  const [notificationListenerEnabled, setNotificationListenerEnabled] = useState(false);
+  const [togglingNotificationListener, setTogglingNotificationListener] = useState(false);
+  const [smsEnabled, setSmsEnabled] = useState(false);
+  const [togglingSms, setTogglingSms] = useState(false);
+  const [contactsEnabled, setContactsEnabled] = useState(false);
+  const [togglingContacts, setTogglingContacts] = useState(false);
+  const [calendarEnabled, setCalendarEnabled] = useState(false);
+  const [togglingCalendar, setTogglingCalendar] = useState(false);
+  const [dndEnabled, setDndEnabled] = useState(false);
+  const [togglingDnd, setTogglingDnd] = useState(false);
+  const [alarmEnabled, setAlarmEnabled] = useState(false);
+  const [togglingAlarm, setTogglingAlarm] = useState(false);
+  const [batteryEnabled, setBatteryEnabled] = useState(false);
+  const [togglingBattery, setTogglingBattery] = useState(false);
 
   const locationEnabled = !!(activeClientToken && locationClientToken === activeClientToken);
 
@@ -72,6 +151,308 @@ export default function HostMenu({ daemonVersion, locationClientToken, activeCli
     return () => { listener.then((h) => h.remove()); };
   }, [locationEnabled, activeClientToken]);
 
+  // Sync notification listener toggle with system state — on mount and when app resumes
+  useEffect(() => {
+    if (!isNative || !NotificationListener) return;
+
+    function syncNotificationListenerState() {
+      Promise.all([
+        NotificationListener!.check(),
+        Preferences.get({ key: "notificationListenerEnabled" }),
+      ]).then(([{ enabled: systemEnabled }, { value: prefValue }]) => {
+        // Enabled only if both system permission is granted AND user toggled on
+        setNotificationListenerEnabled(systemEnabled && prefValue !== "false");
+      });
+    }
+
+    syncNotificationListenerState();
+
+    const listener = CapApp.addListener("resume", () => {
+      syncNotificationListenerState();
+    });
+
+    return () => { listener.then((h) => h.remove()); };
+  }, []);
+
+  async function handleNotificationListenerToggle() {
+    if (!NotificationListener || !request) return;
+    setTogglingNotificationListener(true);
+    try {
+      if (notificationListenerEnabled) {
+        await Preferences.set({ key: "notificationListenerEnabled", value: "false" });
+        await request("device.capability.disable", { capability: "notifications" });
+        setNotificationListenerEnabled(false);
+      } else {
+        const { enabled: systemEnabled } = await NotificationListener.check();
+        if (!systemEnabled) {
+          const result = await NotificationListener.request();
+          if (!result.enabled) return;
+        }
+        const { value: fcmToken } = await Preferences.get({ key: "fcmToken" });
+        if (!fcmToken) { console.warn("No FCM token available"); return; }
+        await Preferences.set({ key: "notificationListenerEnabled", value: "true" });
+        await request("device.capability.enable", { capability: "notifications", fcmToken });
+        setNotificationListenerEnabled(true);
+      }
+    } catch (err) {
+      console.error("Failed to toggle notification listener:", err);
+    } finally {
+      setTogglingNotificationListener(false);
+    }
+  }
+
+  // Sync SMS toggle with permission state — on mount and when app resumes
+  useEffect(() => {
+    if (!isNative || !SmsPermission) return;
+
+    function syncSmsState() {
+      Promise.all([
+        SmsPermission!.check(),
+        Preferences.get({ key: "smsListenerEnabled" }),
+      ]).then(([{ granted }, { value: prefValue }]) => {
+        setSmsEnabled(granted && prefValue !== "false");
+      });
+    }
+
+    syncSmsState();
+
+    const listener = CapApp.addListener("resume", () => {
+      syncSmsState();
+    });
+
+    return () => { listener.then((h) => h.remove()); };
+  }, []);
+
+  async function handleSmsToggle() {
+    if (!SmsPermission || !request) return;
+    setTogglingSms(true);
+    try {
+      if (smsEnabled) {
+        await Preferences.set({ key: "smsListenerEnabled", value: "false" });
+        await request("device.capability.disable", { capability: "sms" });
+        setSmsEnabled(false);
+      } else {
+        const { granted } = await SmsPermission.check();
+        if (!granted) {
+          const result = await SmsPermission.request();
+          if (!result.granted) return;
+        }
+        const { value: fcmToken } = await Preferences.get({ key: "fcmToken" });
+        if (!fcmToken) { console.warn("No FCM token available"); return; }
+        await Preferences.set({ key: "smsListenerEnabled", value: "true" });
+        await request("device.capability.enable", { capability: "sms", fcmToken });
+        setSmsEnabled(true);
+      }
+    } catch (err) {
+      console.error("Failed to toggle SMS access:", err);
+    } finally {
+      setTogglingSms(false);
+    }
+  }
+
+  // Sync contacts toggle with permission state — on mount and when app resumes
+  useEffect(() => {
+    if (!isNative || !ContactsPermission) return;
+
+    function syncContactsState() {
+      Promise.all([
+        ContactsPermission!.check(),
+        Preferences.get({ key: "contactsAccessEnabled" }),
+      ]).then(([{ granted }, { value: prefValue }]) => {
+        setContactsEnabled(granted && prefValue !== "false");
+      });
+    }
+
+    syncContactsState();
+
+    const listener = CapApp.addListener("resume", () => {
+      syncContactsState();
+    });
+
+    return () => { listener.then((h) => h.remove()); };
+  }, []);
+
+  async function handleContactsToggle() {
+    if (!ContactsPermission || !request) return;
+    setTogglingContacts(true);
+    try {
+      if (contactsEnabled) {
+        await Preferences.set({ key: "contactsAccessEnabled", value: "false" });
+        await request("device.capability.disable", { capability: "contacts" });
+        setContactsEnabled(false);
+      } else {
+        const { granted } = await ContactsPermission.check();
+        if (!granted) {
+          const result = await ContactsPermission.request();
+          if (!result.granted) return;
+        }
+        const { value: fcmToken } = await Preferences.get({ key: "fcmToken" });
+        if (!fcmToken) { console.warn("No FCM token available"); return; }
+        await Preferences.set({ key: "contactsAccessEnabled", value: "true" });
+        await request("device.capability.enable", { capability: "contacts", fcmToken });
+        setContactsEnabled(true);
+      }
+    } catch (err) {
+      console.error("Failed to toggle contacts access:", err);
+    } finally {
+      setTogglingContacts(false);
+    }
+  }
+
+  // Sync calendar toggle with permission state — on mount and when app resumes
+  useEffect(() => {
+    if (!isNative || !CalendarPermission) return;
+
+    function syncCalendarState() {
+      Promise.all([
+        CalendarPermission!.check(),
+        Preferences.get({ key: "calendarAccessEnabled" }),
+      ]).then(([{ granted }, { value: prefValue }]) => {
+        setCalendarEnabled(granted && prefValue !== "false");
+      });
+    }
+
+    syncCalendarState();
+
+    const listener = CapApp.addListener("resume", () => {
+      syncCalendarState();
+    });
+
+    return () => { listener.then((h) => h.remove()); };
+  }, []);
+
+  async function handleCalendarToggle() {
+    if (!CalendarPermission || !request) return;
+    setTogglingCalendar(true);
+    try {
+      if (calendarEnabled) {
+        await Preferences.set({ key: "calendarAccessEnabled", value: "false" });
+        await request("device.capability.disable", { capability: "calendar" });
+        setCalendarEnabled(false);
+      } else {
+        const { granted } = await CalendarPermission.check();
+        if (!granted) {
+          const result = await CalendarPermission.request();
+          if (!result.granted) return;
+        }
+        const { value: fcmToken } = await Preferences.get({ key: "fcmToken" });
+        if (!fcmToken) { console.warn("No FCM token available"); return; }
+        await Preferences.set({ key: "calendarAccessEnabled", value: "true" });
+        await request("device.capability.enable", { capability: "calendar", fcmToken });
+        setCalendarEnabled(true);
+      }
+    } catch (err) {
+      console.error("Failed to toggle calendar access:", err);
+    } finally {
+      setTogglingCalendar(false);
+    }
+  }
+
+  // Sync DND access toggle with system state — on mount and when app resumes
+  useEffect(() => {
+    if (!isNative || !DndAccess) return;
+
+    function syncDndState() {
+      DndAccess!.check().then(({ enabled }) => {
+        setDndEnabled(enabled);
+      });
+    }
+
+    syncDndState();
+
+    const listener = CapApp.addListener("resume", () => {
+      syncDndState();
+    });
+
+    return () => { listener.then((h) => h.remove()); };
+  }, []);
+
+  async function handleDndToggle() {
+    if (!DndAccess || !request) return;
+    setTogglingDnd(true);
+    try {
+      if (dndEnabled) {
+        // DND access can only be revoked in system settings, but we unregister from host
+        await request("device.capability.disable", { capability: "dnd" });
+        setDndEnabled(false);
+      } else {
+        const { enabled: systemEnabled } = await DndAccess.check();
+        if (!systemEnabled) {
+          const result = await DndAccess.request();
+          if (!result.enabled) return;
+        }
+        const { value: fcmToken } = await Preferences.get({ key: "fcmToken" });
+        if (!fcmToken) { console.warn("No FCM token available"); return; }
+        await request("device.capability.enable", { capability: "dnd", fcmToken });
+        setDndEnabled(true);
+      }
+    } catch (err) {
+      console.error("Failed to toggle DND access:", err);
+    } finally {
+      setTogglingDnd(false);
+    }
+  }
+
+  // Sync alarm toggle — no permission needed, just device registration
+  useEffect(() => {
+    if (!isNative) return;
+    Preferences.get({ key: "alertAccessEnabled" }).then(({ value }) => {
+      setAlarmEnabled(value === "true");
+    });
+  }, []);
+
+  async function handleAlarmToggle() {
+    if (!request) return;
+    setTogglingAlarm(true);
+    try {
+      if (alarmEnabled) {
+        await Preferences.set({ key: "alertAccessEnabled", value: "false" });
+        await request("device.capability.disable", { capability: "alert" });
+        setAlarmEnabled(false);
+      } else {
+        const { value: fcmToken } = await Preferences.get({ key: "fcmToken" });
+        if (!fcmToken) { console.warn("No FCM token available"); return; }
+        await Preferences.set({ key: "alertAccessEnabled", value: "true" });
+        await request("device.capability.enable", { capability: "alert", fcmToken });
+        setAlarmEnabled(true);
+      }
+    } catch (err) {
+      console.error("Failed to toggle alarm access:", err);
+    } finally {
+      setTogglingAlarm(false);
+    }
+  }
+
+  // Sync battery toggle — no permission needed, just device registration
+  useEffect(() => {
+    if (!isNative) return;
+    Preferences.get({ key: "batteryAccessEnabled" }).then(({ value }) => {
+      setBatteryEnabled(value === "true");
+    });
+  }, []);
+
+  async function handleBatteryToggle() {
+    if (!request) return;
+    setTogglingBattery(true);
+    try {
+      if (batteryEnabled) {
+        await Preferences.set({ key: "batteryAccessEnabled", value: "false" });
+        await request("device.capability.disable", { capability: "battery" });
+        setBatteryEnabled(false);
+      } else {
+        const { value: fcmToken } = await Preferences.get({ key: "fcmToken" });
+        if (!fcmToken) { console.warn("No FCM token available"); return; }
+        await Preferences.set({ key: "batteryAccessEnabled", value: "true" });
+        await request("device.capability.enable", { capability: "battery", fcmToken });
+        setBatteryEnabled(true);
+      }
+    } catch (err) {
+      console.error("Failed to toggle battery access:", err);
+    } finally {
+      setTogglingBattery(false);
+    }
+  }
+
   async function handleLocationToggle() {
     if (!request) return;
     setTogglingLocation(true);
@@ -294,6 +675,90 @@ export default function HostMenu({ daemonVersion, locationClientToken, activeCli
                 <span className="toggle-switch-thumb" />
               </button>
             </label>
+            <label className="drawer-toggle">
+              <span className="drawer-toggle-label">Notification Access</span>
+              <button
+                className={`toggle-switch ${notificationListenerEnabled ? "toggle-switch-on" : ""}`}
+                onClick={handleNotificationListenerToggle}
+                disabled={togglingNotificationListener}
+                role="switch"
+                aria-checked={notificationListenerEnabled}
+              >
+                <span className="toggle-switch-thumb" />
+              </button>
+            </label>
+            <label className="drawer-toggle">
+              <span className="drawer-toggle-label">SMS Access</span>
+              <button
+                className={`toggle-switch ${smsEnabled ? "toggle-switch-on" : ""}`}
+                onClick={handleSmsToggle}
+                disabled={togglingSms}
+                role="switch"
+                aria-checked={smsEnabled}
+              >
+                <span className="toggle-switch-thumb" />
+              </button>
+            </label>
+            <label className="drawer-toggle">
+              <span className="drawer-toggle-label">Contacts Access</span>
+              <button
+                className={`toggle-switch ${contactsEnabled ? "toggle-switch-on" : ""}`}
+                onClick={handleContactsToggle}
+                disabled={togglingContacts}
+                role="switch"
+                aria-checked={contactsEnabled}
+              >
+                <span className="toggle-switch-thumb" />
+              </button>
+            </label>
+            <label className="drawer-toggle">
+              <span className="drawer-toggle-label">Calendar Access</span>
+              <button
+                className={`toggle-switch ${calendarEnabled ? "toggle-switch-on" : ""}`}
+                onClick={handleCalendarToggle}
+                disabled={togglingCalendar}
+                role="switch"
+                aria-checked={calendarEnabled}
+              >
+                <span className="toggle-switch-thumb" />
+              </button>
+            </label>
+            <label className="drawer-toggle">
+              <span className="drawer-toggle-label">Do Not Disturb Control</span>
+              <button
+                className={`toggle-switch ${dndEnabled ? "toggle-switch-on" : ""}`}
+                onClick={handleDndToggle}
+                disabled={togglingDnd}
+                role="switch"
+                aria-checked={dndEnabled}
+              >
+                <span className="toggle-switch-thumb" />
+              </button>
+            </label>
+            <label className="drawer-toggle">
+              <span className="drawer-toggle-label">Alert Access</span>
+              <button
+                className={`toggle-switch ${alarmEnabled ? "toggle-switch-on" : ""}`}
+                onClick={handleAlarmToggle}
+                disabled={togglingAlarm}
+                role="switch"
+                aria-checked={alarmEnabled}
+              >
+                <span className="toggle-switch-thumb" />
+              </button>
+            </label>
+            <label className="drawer-toggle">
+              <span className="drawer-toggle-label">Battery Access</span>
+              <button
+                className={`toggle-switch ${batteryEnabled ? "toggle-switch-on" : ""}`}
+                onClick={handleBatteryToggle}
+                disabled={togglingBattery}
+                role="switch"
+                aria-checked={batteryEnabled}
+              >
+                <span className="toggle-switch-thumb" />
+              </button>
+            </label>
           </div>
         </>
       )}

package/palmier-server/pwa/src/constants.ts

@@ -1,2 +1,2 @@
 /** Bump when a breaking host change is made. */
-export const MIN_HOST_VERSION = "0.6.9";
+export const MIN_HOST_VERSION = "0.7.3";