fix(ios): widget could not get more than 2 classes

Author: hugofnm

app.json

@@ -66,6 +66,10 @@
             "image": "./src/assets/icon.png",
             "prerendered": false
           },
+          "old": {
+            "image": "./src/assets/icons/icon_old.png",
+            "prerendered": false
+          },
           "magnet": {
             "image": "./src/assets/icons/icon_magnet.png",
             "prerendered": false

package.json

@@ -1,7 +1,7 @@
 {
   "name": "unicenotes",
   "main": "expo-router/entry",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "scripts": {
     "start": "expo start --dev-client",
     "android": "expo run:android",

src/app/home.tsx

@@ -13,7 +13,7 @@ import BottomSheet, {
 } from '@gorhom/bottom-sheet';
 import { useRouter } from 'expo-router';
 import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { StyleSheet, View } from 'react-native';
+import { StyleSheet, View, Platform } from 'react-native';
 import {
   ActivityIndicator,
   Avatar,
@@ -63,6 +63,7 @@ export default function HomeScreen() {
 
   useEffect(() => {
     getNextEvent('normal');
+    if (Platform.OS === 'ios') pushWidgetTimeline();
 
     // check in app context if update modal has been shown, if not show it and set it to true
     if (!updateModalShown) {
@@ -88,27 +89,37 @@ export default function HomeScreen() {
       const result = await edtService.getNextEvent(adeid ?? 'demo');
       setNextEvent(result);
       setNextEventLoaded(true);
-      try {
-        const courses = await edtService.getNextTwoCourses(adeid ?? 'demo');
-        NextClassWidgetInstance.updateSnapshot({ courses });
-      } catch {
-        // Widget non disponible en mode dev ou non configuré
-        console.warn('NextClassWidget: Impossible de récupérer les prochains cours pour le widget');
-      }
     }
   }
 
   async function getMyCal() {
     haptics('medium');
     setSelectable(false);
     setLoading(true);
+
     const cal = await edtService.getEDT(adeid ?? 'demo');
     setCalendar(cal);
+    if (Platform.OS === 'ios') {
+      try {
+        NextClassWidgetInstance.updateTimeline(edtService.buildWidgetTimeline(cal));
+      } catch { }
+    }
+
     setSelectable(true);
     setLoading(false);
     router.push('/show-edt');
   }
 
+  async function pushWidgetTimeline() {
+    try {
+      const events = await edtService.getEDT(adeid ?? 'demo');
+      const timeline = edtService.buildWidgetTimeline(events);
+      NextClassWidgetInstance.updateTimeline(timeline);
+    } catch {
+      // widget non configuré ou ADE indisponible
+    }
+  }
+
   async function showUpdateModal() {
     // wait 1 second before showing the update modal
     await new Promise(resolve => setTimeout(resolve, 1500));

src/app/icon-config.tsx

@@ -27,8 +27,6 @@ export default function IconConfigScreen() {
     haptics('medium');
     if (!__DEV__) {
       setAppIcon(value);
-    } else {
-      console.log("Changement d'icône : " + value);
     }
   }
 
@@ -62,6 +60,14 @@ export default function IconConfigScreen() {
         >
           Par défaut
         </Chip>
+        <Chip
+          style={{ ...chipStyle, borderRadius: 0, marginTop: 1 }}
+          textStyle={{ paddingVertical: 8 }}
+          avatar={<Image style={{ width: 24, height: 24 }} source={require('../assets/icons/icon_old.png')} />}
+          onPress={() => changeIconHome('old')}
+        >
+          Old Style
+        </Chip>
         <Chip
           style={{ ...chipStyle, borderRadius: 0, marginTop: 1 }}
           textStyle={{ paddingVertical: 8 }}

src/services/edt.ts

@@ -1,6 +1,6 @@
 import { File, Paths } from 'expo-file-system';
 import ICAL from 'ical.js';
-import type { CalendarEvent, NextEvent, WidgetClass } from '../types';
+import type { CalendarEvent, NextClassWidgetProps, NextEvent, WidgetClass } from '../types';
 import { stringToColour } from '../utils/color';
 
 interface ICALComponent {
@@ -142,6 +142,41 @@ export class EDT {
     return { summary: next.summary, location: next.location };
   }
 
+  async getNextEvent(adeid: string): Promise<NextEvent> {
+    const icalData = await this.fetchEDT(adeid);
+    if (!icalData) {
+      return { summary: 'ADE Indisponible', location: 'Impossible de récupérer le cours.' };
+    }
+    const events = this.parseICal(icalData);
+    return this.findNextEvent(events);
+  }
+
+  private convertToCalendarEvents(events: ICALEvent[]): CalendarEvent[] {
+    return events.map((e, index) => ({
+      id: e.uid ?? String(index),
+      start: { dateTime: e.startDate.toJSDate().toISOString() },
+      end: { dateTime: e.endDate.toJSDate().toISOString() },
+      title: e.summary ?? '',
+      subtitle: e.description ?? '',
+      description: e.location ?? '',
+      color: stringToColour(e.summary ?? ''),
+    }));
+  }
+
+  async getEDT(adeid: string): Promise<CalendarEvent[]> {
+    if (!adeid || adeid === 'demo') return [];
+
+    const icalData = await this.fetchEDT(adeid);
+    if (!icalData) return getCalendarFromCache();
+    const events = this.parseICal(icalData);
+    const calEvents = this.convertToCalendarEvents(events);
+    try {
+      CALENDAR_FILE.write(JSON.stringify(calEvents));
+    } catch { }
+    return calEvents;
+  }
+
+  // Widget
   findNextTwoCourses(events: ICALEvent[]): WidgetClass[] {
     const now = new Date();
     const windowStart = new Date(now.getTime() - 15 * 60 * 1000);
@@ -174,36 +209,61 @@ export class EDT {
     return this.findNextTwoCourses(events);
   }
 
-  async getNextEvent(adeid: string): Promise<NextEvent> {
-    const icalData = await this.fetchEDT(adeid);
-    if (!icalData) {
-      return { summary: 'ADE Indisponible', location: 'Impossible de récupérer le cours.' };
+  buildWidgetTimeline(
+    events: CalendarEvent[],
+  ): Array<{ date: Date; props: NextClassWidgetProps }> {
+    if (events.length === 0) {
+      return [
+        {
+          date: new Date(),
+          props: { courses: [], configured: false },
+        },
+      ];
     }
-    const events = this.parseICal(icalData);
-    return this.findNextEvent(events);
-  }
 
-  private convertToCalendarEvents(events: ICALEvent[]): CalendarEvent[] {
-    return events.map((e, index) => ({
-      id: e.uid ?? String(index),
-      start: { dateTime: e.startDate.toJSDate().toISOString() },
-      end: { dateTime: e.endDate.toJSDate().toISOString() },
-      title: e.summary ?? '',
-      subtitle: e.description ?? '',
-      description: e.location ?? '',
-      color: stringToColour(e.summary ?? ''),
-    }));
-  }
+    const now = new Date();
+    const cutoff = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000); // 7 jours
 
-  async getEDT(adeid: string): Promise<CalendarEvent[]> {
-    const icalData = await this.fetchEDT(adeid);
-    if (!icalData) return getCalendarFromCache();
-    const events = this.parseICal(icalData);
-    const calEvents = this.convertToCalendarEvents(events);
-    try {
-      CALENDAR_FILE.write(JSON.stringify(calEvents));
-    } catch { }
-    return calEvents;
+    const pad = (n: number) => String(n).padStart(2, '0');
+    const fmt = (d: Date) => `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+
+    // Tous les cours futurs triés par heure de début
+    const allFuture = events
+      .filter((e) => new Date(e.end.dateTime) > now)
+      .sort(
+        (a, b) =>
+          new Date(a.start.dateTime).getTime() - new Date(b.start.dateTime).getTime(),
+      );
+
+    // Les 2 prochains cours non encore terminés à partir d'un instant donné
+    const getCoursesAt = (from: Date): WidgetClass[] =>
+      allFuture
+        .filter((e) => new Date(e.end.dateTime) > from)
+        .slice(0, 2)
+        .map((e) => ({
+          title: e.title,
+          room: e.description, // description = location dans CalendarEvent
+          startTime: fmt(new Date(e.start.dateTime)),
+          endTime: fmt(new Date(e.end.dateTime)),
+        }));
+
+    const seen = new Set<number>();
+    const timeline: Array<{ date: Date; props: NextClassWidgetProps }> = [];
+
+    seen.add(now.getTime());
+    timeline.push({ date: now, props: { courses: getCoursesAt(now), configured: true } });
+
+    // Une entrée à chaque fin de cours dans les 24h
+    for (const event of allFuture) {
+      const endDate = new Date(event.end.dateTime);
+      const ms = endDate.getTime();
+      if (endDate <= cutoff && !seen.has(ms)) {
+        seen.add(ms);
+        timeline.push({ date: endDate, props: { courses: getCoursesAt(endDate), configured: true } });
+      }
+    }
+
+    return timeline;
   }
 }
 

src/types/index.ts

@@ -27,6 +27,7 @@ export interface WidgetClass {
 
 export interface NextClassWidgetProps {
   courses: WidgetClass[];
+  configured?: boolean;
 }
 
 export type HapticIntensity =

src/utils/api.ts

@@ -4,4 +4,4 @@ import { haptics } from './haptics';
 export async function handleURL(url: string): Promise<void> {
   haptics('selection');
   await WebBrowser.openBrowserAsync(url);
-}
+}