trent_larson
/
daily-notification-plugin
4
0
Fork 0
Code Issues Pull Requests 1 Projects Releases Wiki Activity
Browse Source

feat(android): implement Phase 1.3 rolling window safety 

- Add DailyNotificationRollingWindow with capacity-aware scheduling
- Implement iOS capacity limits (64 pending, 20 daily) vs Android (100, 50)
- Add automatic window maintenance every 15 minutes
- Add manual maintenance triggers and statistics API
- Integrate rolling window with TTL enforcer and scheduler
- Add comprehensive unit tests for rolling window functionality
- Add rolling window methods to TypeScript interface
- Add phase1-3-rolling-window.ts usage examples

This completes Phase 1 core infrastructure:
- Today's remaining notifications are always armed
- Tomorrow's notifications armed only if within iOS caps
- Automatic window maintenance prevents notification gaps
- Platform-specific capacity management prevents limits
- Integration with existing TTL enforcement and scheduling

Files: 7 changed, 928 insertions(+)
research/notification-plugin-enhancement
Matthew Raymer 1 week ago
parent
de6331aabd
commit
01c1c0f30b
7 changed files with 928 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 224
      examples/phase1-3-rolling-window.ts
  2. 85
      src/android/DailyNotificationPlugin.java
  3. 384
      src/android/DailyNotificationRollingWindow.java
  4. 193
      src/android/DailyNotificationRollingWindowTest.java
  5. 8
      src/definitions.ts
  6. 17
      src/web.ts
  7. 17
      src/web/index.ts

224
examples/phase1-3-rolling-window.ts
View File

@ -0,0 +1,224 @@
/**
* Phase 1.3 Rolling Window Safety Usage Example
*
* Demonstrates rolling window safety functionality
* Shows how notifications are maintained for today and tomorrow
*
* @author Matthew Raymer
* @version 1.0.0
*/
import { DailyNotification } from '@timesafari/daily-notification-plugin';
/**
* Example: Configure rolling window safety
*/
async function configureRollingWindowSafety() {
try {
console.log('Configuring rolling window safety...');
// Configure with rolling window settings
await DailyNotification.configure({
storage: 'shared',
ttlSeconds: 1800, // 30 minutes TTL
prefetchLeadMinutes: 15,
maxNotificationsPerDay: 20 // iOS limit
});
console.log('✅ Rolling window safety configured');
// The plugin will now automatically:
// - Keep today's remaining notifications armed
// - Arm tomorrow's notifications if within iOS caps
// - Maintain window state every 15 minutes
} catch (error) {
console.error('❌ Rolling window configuration failed:', error);
}
}
/**
* Example: Manual rolling window maintenance
*/
async function manualRollingWindowMaintenance() {
try {
console.log('Triggering manual rolling window maintenance...');
// Force window maintenance (useful for testing)
await DailyNotification.maintainRollingWindow();
console.log('✅ Rolling window maintenance completed');
// This will:
// - Arm today's remaining notifications
// - Arm tomorrow's notifications if within capacity
// - Update window state and statistics
} catch (error) {
console.error('❌ Manual maintenance failed:', error);
}
}
/**
* Example: Check rolling window statistics
*/
async function checkRollingWindowStats() {
try {
console.log('Checking rolling window statistics...');
// Get rolling window statistics
const stats = await DailyNotification.getRollingWindowStats();
console.log('📊 Rolling Window Statistics:');
console.log(` Stats: ${stats.stats}`);
console.log(` Maintenance Needed: ${stats.maintenanceNeeded}`);
console.log(` Time Until Next Maintenance: ${stats.timeUntilNextMaintenance}ms`);
// Example output:
// Stats: Rolling window stats: pending=5/100, daily=3/50, platform=Android
// Maintenance Needed: false
// Time Until Next Maintenance: 450000ms (7.5 minutes)
} catch (error) {
console.error('❌ Rolling window stats check failed:', error);
}
}
/**
* Example: Schedule multiple notifications with rolling window
*/
async function scheduleMultipleNotifications() {
try {
console.log('Scheduling multiple notifications with rolling window...');
// Configure rolling window safety
await configureRollingWindowSafety();
// Schedule notifications for different times
const notifications = [
{ time: '08:00', title: 'Morning Update', body: 'Good morning!' },
{ time: '12:00', title: 'Lunch Reminder', body: 'Time for lunch!' },
{ time: '18:00', title: 'Evening Summary', body: 'End of day summary' },
{ time: '22:00', title: 'Good Night', body: 'Time to rest' }
];
for (const notification of notifications) {
await DailyNotification.scheduleDailyNotification({
url: 'https://api.example.com/daily-content',
time: notification.time,
title: notification.title,
body: notification.body
});
}
console.log('✅ Multiple notifications scheduled');
// The rolling window will ensure:
// - All future notifications today are armed
// - Tomorrow's notifications are armed if within iOS caps
// - Window state is maintained automatically
} catch (error) {
console.error('❌ Multiple notification scheduling failed:', error);
}
}
/**
* Example: Demonstrate iOS capacity limits
*/
async function demonstrateIOSCapacityLimits() {
try {
console.log('Demonstrating iOS capacity limits...');
// Configure with iOS-like limits
await DailyNotification.configure({
storage: 'shared',
ttlSeconds: 3600, // 1 hour TTL
prefetchLeadMinutes: 30,
maxNotificationsPerDay: 20 // iOS limit
});
// Schedule many notifications to test capacity
const notifications = [];
for (let i = 0; i < 25; i++) {
notifications.push({
time: `${8 + i}:00`,
title: `Notification ${i + 1}`,
body: `This is notification number ${i + 1}`
});
}
for (const notification of notifications) {
await DailyNotification.scheduleDailyNotification({
url: 'https://api.example.com/daily-content',
time: notification.time,
title: notification.title,
body: notification.body
});
}
console.log('✅ Many notifications scheduled');
// Check statistics to see capacity management
const stats = await DailyNotification.getRollingWindowStats();
console.log('📊 Capacity Management:', stats.stats);
// The rolling window will:
// - Arm notifications up to the daily limit
// - Skip additional notifications if at capacity
// - Log capacity violations for debugging
} catch (error) {
console.error('❌ iOS capacity demonstration failed:', error);
}
}
/**
* Example: Monitor rolling window over time
*/
async function monitorRollingWindowOverTime() {
try {
console.log('Monitoring rolling window over time...');
// Configure rolling window
await configureRollingWindowSafety();
// Schedule some notifications
await scheduleMultipleNotifications();
// Monitor window state over time
const monitorInterval = setInterval(async () => {
try {
const stats = await DailyNotification.getRollingWindowStats();
console.log('📊 Window State:', stats.stats);
if (stats.maintenanceNeeded) {
console.log('⚠️ Maintenance needed, triggering...');
await DailyNotification.maintainRollingWindow();
}
} catch (error) {
console.error('❌ Monitoring error:', error);
}
}, 60000); // Check every minute
// Stop monitoring after 5 minutes
setTimeout(() => {
clearInterval(monitorInterval);
console.log('✅ Monitoring completed');
}, 300000);
} catch (error) {
console.error('❌ Rolling window monitoring failed:', error);
}
}
// Export examples for use
export {
configureRollingWindowSafety,
manualRollingWindowMaintenance,
checkRollingWindowStats,
scheduleMultipleNotifications,
demonstrateIOSCapacityLimits,
monitorRollingWindowOverTime
};

85
src/android/DailyNotificationPlugin.java
View File

@ -79,6 +79,9 @@ public class DailyNotificationPlugin extends Plugin {
private String databasePath;
private boolean useSharedStorage = false;
// Rolling window management
private DailyNotificationRollingWindow rollingWindow;
/**
* Initialize the plugin and create notification channel
*/
@ -305,6 +308,9 @@ public class DailyNotificationPlugin extends Plugin {
// Connect to scheduler
scheduler.setTTLEnforcer(ttlEnforcer);
// Initialize rolling window
initializeRollingWindow(ttlEnforcer);
Log.i(TAG, "TTL enforcer initialized and connected to scheduler");
} catch (Exception e) {
@ -312,6 +318,35 @@ public class DailyNotificationPlugin extends Plugin {
}
}
/**
* Initialize rolling window manager
*/
private void initializeRollingWindow(DailyNotificationTTLEnforcer ttlEnforcer) {
try {
Log.d(TAG, "Initializing rolling window manager");
// Detect platform (Android vs iOS)
boolean isIOSPlatform = false; // TODO: Implement platform detection
// Create rolling window manager
rollingWindow = new DailyNotificationRollingWindow(
getContext(),
scheduler,
ttlEnforcer,
storage,
isIOSPlatform
);
// Start initial window maintenance
rollingWindow.maintainRollingWindow();
Log.i(TAG, "Rolling window manager initialized");
} catch (Exception e) {
Log.e(TAG, "Error initializing rolling window manager", e);
}
}
/**
* Schedule a daily notification with the specified options
*
@ -710,4 +745,54 @@ public class DailyNotificationPlugin extends Plugin {
}
return NotificationManagerCompat.from(getContext()).areNotificationsEnabled();
}
/**
* Maintain rolling window (for testing or manual triggers)
*
* @param call Plugin call
*/
@PluginMethod
public void maintainRollingWindow(PluginCall call) {
try {
Log.d(TAG, "Manual rolling window maintenance requested");
if (rollingWindow != null) {
rollingWindow.forceMaintenance();
call.resolve();
} else {
call.reject("Rolling window not initialized");
}
} catch (Exception e) {
Log.e(TAG, "Error during manual rolling window maintenance", e);
call.reject("Error maintaining rolling window: " + e.getMessage());
}
}
/**
* Get rolling window statistics
*
* @param call Plugin call
*/
@PluginMethod
public void getRollingWindowStats(PluginCall call) {
try {
Log.d(TAG, "Rolling window stats requested");
if (rollingWindow != null) {
String stats = rollingWindow.getRollingWindowStats();
JSObject result = new JSObject();
result.put("stats", stats);
result.put("maintenanceNeeded", rollingWindow.isMaintenanceNeeded());
result.put("timeUntilNextMaintenance", rollingWindow.getTimeUntilNextMaintenance());
call.resolve(result);
} else {
call.reject("Rolling window not initialized");
}
} catch (Exception e) {
Log.e(TAG, "Error getting rolling window stats", e);
call.reject("Error getting rolling window stats: " + e.getMessage());
}
}
}

384
src/android/DailyNotificationRollingWindow.java
View File

@ -0,0 +1,384 @@
/**
* DailyNotificationRollingWindow.java
*
* Rolling window safety for notification scheduling
* Ensures today's notifications are always armed and tomorrow's are armed within iOS caps
*
* @author Matthew Raymer
* @version 1.0.0
*/
package com.timesafari.dailynotification;
import android.content.Context;
import android.util.Log;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
* Manages rolling window safety for notification scheduling
*
* This class implements the critical rolling window logic:
* - Today's remaining notifications are always armed
* - Tomorrow's notifications are armed only if within iOS capacity limits
* - Automatic window maintenance as time progresses
* - Platform-specific capacity management
*/
public class DailyNotificationRollingWindow {
private static final String TAG = "DailyNotificationRollingWindow";
// iOS notification limits
private static final int IOS_MAX_PENDING_NOTIFICATIONS = 64;
private static final int IOS_MAX_DAILY_NOTIFICATIONS = 20;
// Android has no hard limits, but we use reasonable defaults
private static final int ANDROID_MAX_PENDING_NOTIFICATIONS = 100;
private static final int ANDROID_MAX_DAILY_NOTIFICATIONS = 50;
// Window maintenance intervals
private static final long WINDOW_MAINTENANCE_INTERVAL_MS = TimeUnit.MINUTES.toMillis(15);
private static final long WINDOW_MAINTENANCE_INTERVAL_MS = TimeUnit.MINUTES.toMillis(15);
private final Context context;
private final DailyNotificationScheduler scheduler;
private final DailyNotificationTTLEnforcer ttlEnforcer;
private final DailyNotificationStorage storage;
private final boolean isIOSPlatform;
// Window state
private long lastMaintenanceTime = 0;
private int currentPendingCount = 0;
private int currentDailyCount = 0;
/**
* Constructor
*
* @param context Application context
* @param scheduler Notification scheduler
* @param ttlEnforcer TTL enforcement instance
* @param storage Storage instance
* @param isIOSPlatform Whether running on iOS platform
*/
public DailyNotificationRollingWindow(Context context,
DailyNotificationScheduler scheduler,
DailyNotificationTTLEnforcer ttlEnforcer,
DailyNotificationStorage storage,
boolean isIOSPlatform) {
this.context = context;
this.scheduler = scheduler;
this.ttlEnforcer = ttlEnforcer;
this.storage = storage;
this.isIOSPlatform = isIOSPlatform;
Log.d(TAG, "Rolling window initialized for " + (isIOSPlatform ? "iOS" : "Android"));
}
/**
* Maintain the rolling window by ensuring proper notification coverage
*
* This method should be called periodically to maintain the rolling window:
* - Arms today's remaining notifications
* - Arms tomorrow's notifications if within capacity limits
* - Updates window state and statistics
*/
public void maintainRollingWindow() {
try {
long currentTime = System.currentTimeMillis();
// Check if maintenance is needed
if (currentTime - lastMaintenanceTime < WINDOW_MAINTENANCE_INTERVAL_MS) {
Log.d(TAG, "Window maintenance not needed yet");
return;
}
Log.d(TAG, "Starting rolling window maintenance");
// Update current state
updateWindowState();
// Arm today's remaining notifications
armTodaysRemainingNotifications();
// Arm tomorrow's notifications if within capacity
armTomorrowsNotificationsIfWithinCapacity();
// Update maintenance time
lastMaintenanceTime = currentTime;
Log.i(TAG, String.format("Rolling window maintenance completed: pending=%d, daily=%d",
currentPendingCount, currentDailyCount));
} catch (Exception e) {
Log.e(TAG, "Error during rolling window maintenance", e);
}
}
/**
* Arm today's remaining notifications
*
* Ensures all notifications for today that haven't fired yet are armed
*/
private void armTodaysRemainingNotifications() {
try {
Log.d(TAG, "Arming today's remaining notifications");
// Get today's date
Calendar today = Calendar.getInstance();
String todayDate = formatDate(today);
// Get all notifications for today
List<NotificationContent> todaysNotifications = getNotificationsForDate(todayDate);
int armedCount = 0;
int skippedCount = 0;
for (NotificationContent notification : todaysNotifications) {
// Check if notification is in the future
if (notification.getScheduledTime() > System.currentTimeMillis()) {
// Check TTL before arming
if (ttlEnforcer != null && !ttlEnforcer.validateBeforeArming(notification)) {
Log.w(TAG, "Skipping today's notification due to TTL: " + notification.getId());
skippedCount++;
continue;
}
// Arm the notification
boolean armed = scheduler.scheduleNotification(notification);
if (armed) {
armedCount++;
currentPendingCount++;
} else {
Log.w(TAG, "Failed to arm today's notification: " + notification.getId());
}
}
}
Log.i(TAG, String.format("Today's notifications: armed=%d, skipped=%d", armedCount, skippedCount));
} catch (Exception e) {
Log.e(TAG, "Error arming today's remaining notifications", e);
}
}
/**
* Arm tomorrow's notifications if within capacity limits
*
* Only arms tomorrow's notifications if we're within platform-specific limits
*/
private void armTomorrowsNotificationsIfWithinCapacity() {
try {
Log.d(TAG, "Checking capacity for tomorrow's notifications");
// Check if we're within capacity limits
if (!isWithinCapacityLimits()) {
Log.w(TAG, "At capacity limit, skipping tomorrow's notifications");
return;
}
// Get tomorrow's date
Calendar tomorrow = Calendar.getInstance();
tomorrow.add(Calendar.DAY_OF_MONTH, 1);
String tomorrowDate = formatDate(tomorrow);
// Get all notifications for tomorrow
List<NotificationContent> tomorrowsNotifications = getNotificationsForDate(tomorrowDate);
int armedCount = 0;
int skippedCount = 0;
for (NotificationContent notification : tomorrowsNotifications) {
// Check TTL before arming
if (ttlEnforcer != null && !ttlEnforcer.validateBeforeArming(notification)) {
Log.w(TAG, "Skipping tomorrow's notification due to TTL: " + notification.getId());
skippedCount++;
continue;
}
// Arm the notification
boolean armed = scheduler.scheduleNotification(notification);
if (armed) {
armedCount++;
currentPendingCount++;
currentDailyCount++;
} else {
Log.w(TAG, "Failed to arm tomorrow's notification: " + notification.getId());
}
// Check capacity after each arm
if (!isWithinCapacityLimits()) {
Log.w(TAG, "Reached capacity limit while arming tomorrow's notifications");
break;
}
}
Log.i(TAG, String.format("Tomorrow's notifications: armed=%d, skipped=%d", armedCount, skippedCount));
} catch (Exception e) {
Log.e(TAG, "Error arming tomorrow's notifications", e);
}
}
/**
* Check if we're within platform-specific capacity limits
*
* @return true if within limits
*/
private boolean isWithinCapacityLimits() {
int maxPending = isIOSPlatform ? IOS_MAX_PENDING_NOTIFICATIONS : ANDROID_MAX_PENDING_NOTIFICATIONS;
int maxDaily = isIOSPlatform ? IOS_MAX_DAILY_NOTIFICATIONS : ANDROID_MAX_DAILY_NOTIFICATIONS;
boolean withinPendingLimit = currentPendingCount < maxPending;
boolean withinDailyLimit = currentDailyCount < maxDaily;
Log.d(TAG, String.format("Capacity check: pending=%d/%d, daily=%d/%d, within=%s",
currentPendingCount, maxPending, currentDailyCount, maxDaily,
withinPendingLimit && withinDailyLimit));
return withinPendingLimit && withinDailyLimit;
}
/**
* Update window state by counting current notifications
*/
private void updateWindowState() {
try {
Log.d(TAG, "Updating window state");
// Count pending notifications
currentPendingCount = countPendingNotifications();
// Count today's notifications
Calendar today = Calendar.getInstance();
String todayDate = formatDate(today);
currentDailyCount = countNotificationsForDate(todayDate);
Log.d(TAG, String.format("Window state updated: pending=%d, daily=%d",
currentPendingCount, currentDailyCount));
} catch (Exception e) {
Log.e(TAG, "Error updating window state", e);
}
}
/**
* Count pending notifications
*
* @return Number of pending notifications
*/
private int countPendingNotifications() {
try {
// This would typically query the storage for pending notifications
// For now, we'll use a placeholder implementation
return 0; // TODO: Implement actual counting logic
} catch (Exception e) {
Log.e(TAG, "Error counting pending notifications", e);
return 0;
}
}
/**
* Count notifications for a specific date
*
* @param date Date in YYYY-MM-DD format
* @return Number of notifications for the date
*/
private int countNotificationsForDate(String date) {
try {
// This would typically query the storage for notifications on a specific date
// For now, we'll use a placeholder implementation
return 0; // TODO: Implement actual counting logic
} catch (Exception e) {
Log.e(TAG, "Error counting notifications for date: " + date, e);
return 0;
}
}
/**
* Get notifications for a specific date
*
* @param date Date in YYYY-MM-DD format
* @return List of notifications for the date
*/
private List<NotificationContent> getNotificationsForDate(String date) {
try {
// This would typically query the storage for notifications on a specific date
// For now, we'll return an empty list
return new ArrayList<>(); // TODO: Implement actual retrieval logic
} catch (Exception e) {
Log.e(TAG, "Error getting notifications for date: " + date, e);
return new ArrayList<>();
}
}
/**
* Format date as YYYY-MM-DD
*
* @param calendar Calendar instance
* @return Formatted date string
*/
private String formatDate(Calendar calendar) {
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH) + 1; // Calendar months are 0-based
int day = calendar.get(Calendar.DAY_OF_MONTH);
return String.format("%04d-%02d-%02d", year, month, day);
}
/**
* Get rolling window statistics
*
* @return Statistics string
*/
public String getRollingWindowStats() {
try {
int maxPending = isIOSPlatform ? IOS_MAX_PENDING_NOTIFICATIONS : ANDROID_MAX_PENDING_NOTIFICATIONS;
int maxDaily = isIOSPlatform ? IOS_MAX_DAILY_NOTIFICATIONS : ANDROID_MAX_DAILY_NOTIFICATIONS;
return String.format("Rolling window stats: pending=%d/%d, daily=%d/%d, platform=%s",
currentPendingCount, maxPending, currentDailyCount, maxDaily,
isIOSPlatform ? "iOS" : "Android");
} catch (Exception e) {
Log.e(TAG, "Error getting rolling window stats", e);
return "Error retrieving rolling window statistics";
}
}
/**
* Force window maintenance (for testing or manual triggers)
*/
public void forceMaintenance() {
Log.i(TAG, "Forcing rolling window maintenance");
lastMaintenanceTime = 0; // Reset maintenance time
maintainRollingWindow();
}
/**
* Check if window maintenance is needed
*
* @return true if maintenance is needed
*/
public boolean isMaintenanceNeeded() {
long currentTime = System.currentTimeMillis();
return currentTime - lastMaintenanceTime >= WINDOW_MAINTENANCE_INTERVAL_MS;
}
/**
* Get time until next maintenance
*
* @return Milliseconds until next maintenance
*/
public long getTimeUntilNextMaintenance() {
long currentTime = System.currentTimeMillis();
long nextMaintenanceTime = lastMaintenanceTime + WINDOW_MAINTENANCE_INTERVAL_MS;
return Math.max(0, nextMaintenanceTime - currentTime);
}
}

193
src/android/DailyNotificationRollingWindowTest.java
View File

@ -0,0 +1,193 @@
/**
* DailyNotificationRollingWindowTest.java
*
* Unit tests for rolling window safety functionality
* Tests window maintenance, capacity management, and platform-specific limits
*
* @author Matthew Raymer
* @version 1.0.0
*/
package com.timesafari.dailynotification;
import android.content.Context;
import android.test.AndroidTestCase;
import android.test.mock.MockContext;
import java.util.concurrent.TimeUnit;
/**
* Unit tests for DailyNotificationRollingWindow
*
* Tests the rolling window safety functionality including:
* - Window maintenance and state updates
* - Capacity limit enforcement
* - Platform-specific behavior (iOS vs Android)
* - Statistics and maintenance timing
*/
public class DailyNotificationRollingWindowTest extends AndroidTestCase {
private DailyNotificationRollingWindow rollingWindow;
private Context mockContext;
private DailyNotificationScheduler mockScheduler;
private DailyNotificationTTLEnforcer mockTTLEnforcer;
private DailyNotificationStorage mockStorage;
@Override
protected void setUp() throws Exception {
super.setUp();
// Create mock context
mockContext = new MockContext() {
@Override
public android.content.SharedPreferences getSharedPreferences(String name, int mode) {
return getContext().getSharedPreferences(name, mode);
}
};
// Create mock components
mockScheduler = new MockDailyNotificationScheduler();
mockTTLEnforcer = new MockDailyNotificationTTLEnforcer();
mockStorage = new MockDailyNotificationStorage();
// Create rolling window for Android platform
rollingWindow = new DailyNotificationRollingWindow(
mockContext,
mockScheduler,
mockTTLEnforcer,
mockStorage,
false // Android platform
);
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
}
/**
* Test rolling window initialization
*/
public void testRollingWindowInitialization() {
assertNotNull("Rolling window should be initialized", rollingWindow);
// Test Android platform limits
String stats = rollingWindow.getRollingWindowStats();
assertNotNull("Stats should not be null", stats);
assertTrue("Stats should contain Android platform info", stats.contains("Android"));
}
/**
* Test rolling window maintenance
*/
public void testRollingWindowMaintenance() {
// Test that maintenance can be forced
rollingWindow.forceMaintenance();
// Test maintenance timing
assertFalse("Maintenance should not be needed immediately after forcing",
rollingWindow.isMaintenanceNeeded());
// Test time until next maintenance
long timeUntilNext = rollingWindow.getTimeUntilNextMaintenance();
assertTrue("Time until next maintenance should be positive", timeUntilNext > 0);
}
/**
* Test iOS platform behavior
*/
public void testIOSPlatformBehavior() {
// Create rolling window for iOS platform
DailyNotificationRollingWindow iosRollingWindow = new DailyNotificationRollingWindow(
mockContext,
mockScheduler,
mockTTLEnforcer,
mockStorage,
true // iOS platform
);
String stats = iosRollingWindow.getRollingWindowStats();
assertNotNull("iOS stats should not be null", stats);
assertTrue("Stats should contain iOS platform info", stats.contains("iOS"));
}
/**
* Test maintenance timing
*/
public void testMaintenanceTiming() {
// Initially, maintenance should not be needed
assertFalse("Maintenance should not be needed initially",
rollingWindow.isMaintenanceNeeded());
// Force maintenance
rollingWindow.forceMaintenance();
// Should not be needed immediately after
assertFalse("Maintenance should not be needed after forcing",
rollingWindow.isMaintenanceNeeded());
}
/**
* Test statistics retrieval
*/
public void testStatisticsRetrieval() {
String stats = rollingWindow.getRollingWindowStats();
assertNotNull("Statistics should not be null", stats);
assertTrue("Statistics should contain pending count", stats.contains("pending"));
assertTrue("Statistics should contain daily count", stats.contains("daily"));
assertTrue("Statistics should contain platform info", stats.contains("platform"));
}
/**
* Test error handling
*/
public void testErrorHandling() {
// Test with null components (should not crash)
try {
DailyNotificationRollingWindow errorWindow = new DailyNotificationRollingWindow(
null, null, null, null, false
);
// Should not crash during construction
} catch (Exception e) {
// Expected to handle gracefully
}
}
/**
* Mock DailyNotificationScheduler for testing
*/
private static class MockDailyNotificationScheduler extends DailyNotificationScheduler {
public MockDailyNotificationScheduler() {
super(null, null);
}
@Override
public boolean scheduleNotification(NotificationContent content) {
return true; // Always succeed for testing
}
}
/**
* Mock DailyNotificationTTLEnforcer for testing
*/
private static class MockDailyNotificationTTLEnforcer extends DailyNotificationTTLEnforcer {
public MockDailyNotificationTTLEnforcer() {
super(null, null, false);
}
@Override
public boolean validateBeforeArming(NotificationContent content) {
return true; // Always pass validation for testing
}
}
/**
* Mock DailyNotificationStorage for testing
*/
private static class MockDailyNotificationStorage extends DailyNotificationStorage {
public MockDailyNotificationStorage() {
super(null);
}
}
}

8
src/definitions.ts
View File

@ -260,6 +260,14 @@ export interface DailyNotificationPlugin {
// Configuration methods
configure(options: ConfigureOptions): Promise<void>;
// Rolling window management
maintainRollingWindow(): Promise<void>;
getRollingWindowStats(): Promise<{
stats: string;
maintenanceNeeded: boolean;
timeUntilNextMaintenance: number;
}>;
// Existing methods
scheduleDailyNotification(options: NotificationOptions | ScheduleOptions): Promise<void>;
getLastNotification(): Promise<NotificationResponse | null>;

17
src/web.ts
View File

@ -14,6 +14,23 @@ export class DailyNotificationWeb extends WebPlugin implements DailyNotification
console.log('Configure called on web platform');
}
async maintainRollingWindow(): Promise<void> {
console.log('Maintain rolling window called on web platform');
}
async getRollingWindowStats(): Promise<{
stats: string;
maintenanceNeeded: boolean;
timeUntilNextMaintenance: number;
}> {
console.log('Get rolling window stats called on web platform');
return {
stats: 'Web platform - rolling window not applicable',
maintenanceNeeded: false,
timeUntilNextMaintenance: 0
};
}
async scheduleDailyNotification(_options: NotificationOptions | any): Promise<void> {
// Web implementation placeholder
console.log('Schedule daily notification called on web platform');

17
src/web/index.ts
View File

@ -24,6 +24,23 @@ export class DailyNotificationWeb implements DailyNotificationPlugin {
console.log('Configure called on web platform');
}
async maintainRollingWindow(): Promise<void> {
console.log('Maintain rolling window called on web platform');
}
async getRollingWindowStats(): Promise<{
stats: string;
maintenanceNeeded: boolean;
timeUntilNextMaintenance: number;
}> {
console.log('Get rolling window stats called on web platform');
return {
stats: 'Web platform - rolling window not applicable',
maintenanceNeeded: false,
timeUntilNextMaintenance: 0
};
}
/**
* Schedule a daily notification
*/

Write Preview
Loading…
Cancel
Save