Browse Source
- 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
7 changed files with 928 additions and 0 deletions
@ -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 |
||||
|
}; |
||||
@ -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); |
||||
|
} |
||||
|
} |
||||
@ -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); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue