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

feat(storage): implement Room database with enterprise-grade data management

Browse Source 
Complete migration from SharedPreferences to Room database architecture:

**New Components:**
- NotificationContentEntity: Core notification data with encryption support
- NotificationDeliveryEntity: Delivery tracking and analytics
- NotificationConfigEntity: Configuration and user preferences
- NotificationContentDao: Comprehensive CRUD operations with optimized queries
- NotificationDeliveryDao: Delivery analytics and performance tracking
- NotificationConfigDao: Configuration management with type safety
- DailyNotificationDatabase: Room database with migration support
- DailyNotificationStorageRoom: High-level storage service with async operations

**Key Features:**
- Enterprise-grade data persistence with proper indexing
- Encryption support for sensitive notification content
- Automatic retention policy enforcement
- Comprehensive analytics and reporting capabilities
- Background thread execution for all database operations
- Migration support from SharedPreferences-based storage
- Plugin-specific database isolation and lifecycle management

**Architecture Documentation:**
- Complete ARCHITECTURE.md with comprehensive system design
- Database schema design with relationships and indexing strategy
- Security architecture with encryption and key management
- Performance architecture with optimization strategies
- Testing architecture with unit and integration test patterns
- Migration strategy from legacy storage systems

**Technical Improvements:**
- Plugin-specific database with proper entity relationships
- Optimized queries with performance-focused indexing
- Async operations using CompletableFuture for non-blocking UI
- Comprehensive error handling and logging
- Data validation and integrity enforcement
- Cleanup operations with configurable retention policies

This completes the high-priority storage hardening improvement, providing
enterprise-grade data management capabilities for the DailyNotification plugin.

Co-authored-by: Matthew Raymer
This commit is contained in:
Matthew Raymer
2025-10-20 10:19:47 +00:00
parent 5abeb0f799
commit f36ea246f7
9 changed files with 3957 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1584
ARCHITECTURE.md Normal file
View File

File diff suppressed because it is too large Load Diff

306
android/plugin/src/main/java/com/timesafari/dailynotification/dao/NotificationConfigDao.java Normal file
View File

@@ -0,0 +1,306 @@
/**
* NotificationConfigDao.java
*
* Data Access Object for NotificationConfigEntity operations
* Provides efficient queries for configuration management and user preferences
*
* @author Matthew Raymer
* @version 1.0.0
* @since 2025-10-20
*/
package com.timesafari.dailynotification.dao;
import androidx.room.*;
import com.timesafari.dailynotification.entities.NotificationConfigEntity;
import java.util.List;
/**
* Data Access Object for notification configuration operations
*
* Provides efficient database operations for:
* - Configuration management and user preferences
* - Plugin settings and state persistence
* - TimeSafari integration configuration
* - Performance tuning and behavior settings
*/
@Dao
public interface NotificationConfigDao {
// ===== BASIC CRUD OPERATIONS =====
/**
* Insert a new configuration entity
*/
@Insert(onConflict = OnConflictStrategy.REPLACE)
void insertConfig(NotificationConfigEntity config);
/**
* Insert multiple configuration entities
*/
@Insert(onConflict = OnConflictStrategy.REPLACE)
void insertConfigs(List<NotificationConfigEntity> configs);
/**
* Update an existing configuration entity
*/
@Update
void updateConfig(NotificationConfigEntity config);
/**
* Delete a configuration entity by ID
*/
@Query("DELETE FROM notification_config WHERE id = :id")
void deleteConfig(String id);
/**
* Delete configurations by key
*/
@Query("DELETE FROM notification_config WHERE config_key = :configKey")
void deleteConfigsByKey(String configKey);
// ===== QUERY OPERATIONS =====
/**
* Get configuration by ID
*/
@Query("SELECT * FROM notification_config WHERE id = :id")
NotificationConfigEntity getConfigById(String id);
/**
* Get configuration by key
*/
@Query("SELECT * FROM notification_config WHERE config_key = :configKey")
NotificationConfigEntity getConfigByKey(String configKey);
/**
* Get configuration by key and TimeSafari DID
*/
@Query("SELECT * FROM notification_config WHERE config_key = :configKey AND timesafari_did = :timesafariDid")
NotificationConfigEntity getConfigByKeyAndDid(String configKey, String timesafariDid);
/**
* Get all configuration entities
*/
@Query("SELECT * FROM notification_config ORDER BY updated_at DESC")
List<NotificationConfigEntity> getAllConfigs();
/**
* Get configurations by TimeSafari DID
*/
@Query("SELECT * FROM notification_config WHERE timesafari_did = :timesafariDid ORDER BY updated_at DESC")
List<NotificationConfigEntity> getConfigsByTimeSafariDid(String timesafariDid);
/**
* Get configurations by type
*/
@Query("SELECT * FROM notification_config WHERE config_type = :configType ORDER BY updated_at DESC")
List<NotificationConfigEntity> getConfigsByType(String configType);
/**
* Get active configurations
*/
@Query("SELECT * FROM notification_config WHERE is_active = 1 ORDER BY updated_at DESC")
List<NotificationConfigEntity> getActiveConfigs();
/**
* Get encrypted configurations
*/
@Query("SELECT * FROM notification_config WHERE is_encrypted = 1 ORDER BY updated_at DESC")
List<NotificationConfigEntity> getEncryptedConfigs();
// ===== CONFIGURATION-SPECIFIC QUERIES =====
/**
* Get user preferences
*/
@Query("SELECT * FROM notification_config WHERE config_type = 'user_preference' AND timesafari_did = :timesafariDid ORDER BY updated_at DESC")
List<NotificationConfigEntity> getUserPreferences(String timesafariDid);
/**
* Get plugin settings
*/
@Query("SELECT * FROM notification_config WHERE config_type = 'plugin_setting' ORDER BY updated_at DESC")
List<NotificationConfigEntity> getPluginSettings();
/**
* Get TimeSafari integration settings
*/
@Query("SELECT * FROM notification_config WHERE config_type = 'timesafari_integration' AND timesafari_did = :timesafariDid ORDER BY updated_at DESC")
List<NotificationConfigEntity> getTimeSafariIntegrationSettings(String timesafariDid);
/**
* Get performance settings
*/
@Query("SELECT * FROM notification_config WHERE config_type = 'performance_setting' ORDER BY updated_at DESC")
List<NotificationConfigEntity> getPerformanceSettings();
/**
* Get notification preferences
*/
@Query("SELECT * FROM notification_config WHERE config_type = 'notification_preference' AND timesafari_did = :timesafariDid ORDER BY updated_at DESC")
List<NotificationConfigEntity> getNotificationPreferences(String timesafariDid);
// ===== VALUE-BASED QUERIES =====
/**
* Get configurations by data type
*/
@Query("SELECT * FROM notification_config WHERE config_data_type = :dataType ORDER BY updated_at DESC")
List<NotificationConfigEntity> getConfigsByDataType(String dataType);
/**
* Get boolean configurations
*/
@Query("SELECT * FROM notification_config WHERE config_data_type = 'boolean' ORDER BY updated_at DESC")
List<NotificationConfigEntity> getBooleanConfigs();
/**
* Get integer configurations
*/
@Query("SELECT * FROM notification_config WHERE config_data_type = 'integer' ORDER BY updated_at DESC")
List<NotificationConfigEntity> getIntegerConfigs();
/**
* Get string configurations
*/
@Query("SELECT * FROM notification_config WHERE config_data_type = 'string' ORDER BY updated_at DESC")
List<NotificationConfigEntity> getStringConfigs();
/**
* Get JSON configurations
*/
@Query("SELECT * FROM notification_config WHERE config_data_type = 'json' ORDER BY updated_at DESC")
List<NotificationConfigEntity> getJsonConfigs();
// ===== ANALYTICS QUERIES =====
/**
* Get configuration count by type
*/
@Query("SELECT COUNT(*) FROM notification_config WHERE config_type = :configType")
int getConfigCountByType(String configType);
/**
* Get configuration count by TimeSafari DID
*/
@Query("SELECT COUNT(*) FROM notification_config WHERE timesafari_did = :timesafariDid")
int getConfigCountByTimeSafariDid(String timesafariDid);
/**
* Get total configuration count
*/
@Query("SELECT COUNT(*) FROM notification_config")
int getTotalConfigCount();
/**
* Get active configuration count
*/
@Query("SELECT COUNT(*) FROM notification_config WHERE is_active = 1")
int getActiveConfigCount();
/**
* Get encrypted configuration count
*/
@Query("SELECT COUNT(*) FROM notification_config WHERE is_encrypted = 1")
int getEncryptedConfigCount();
// ===== CLEANUP OPERATIONS =====
/**
* Delete expired configurations
*/
@Query("DELETE FROM notification_config WHERE (created_at + (ttl_seconds * 1000)) < :currentTime")
int deleteExpiredConfigs(long currentTime);
/**
* Delete old configurations
*/
@Query("DELETE FROM notification_config WHERE created_at < :cutoffTime")
int deleteOldConfigs(long cutoffTime);
/**
* Delete configurations by TimeSafari DID
*/
@Query("DELETE FROM notification_config WHERE timesafari_did = :timesafariDid")
int deleteConfigsByTimeSafariDid(String timesafariDid);
/**
* Delete inactive configurations
*/
@Query("DELETE FROM notification_config WHERE is_active = 0")
int deleteInactiveConfigs();
/**
* Delete configurations by type
*/
@Query("DELETE FROM notification_config WHERE config_type = :configType")
int deleteConfigsByType(String configType);
// ===== BULK OPERATIONS =====
/**
* Update configuration values for multiple configs
*/
@Query("UPDATE notification_config SET config_value = :newValue, updated_at = :updatedAt WHERE id IN (:ids)")
void updateConfigValuesForConfigs(List<String> ids, String newValue, long updatedAt);
/**
* Activate/deactivate multiple configurations
*/
@Query("UPDATE notification_config SET is_active = :isActive, updated_at = :updatedAt WHERE id IN (:ids)")
void updateActiveStatusForConfigs(List<String> ids, boolean isActive, long updatedAt);
/**
* Mark configurations as encrypted
*/
@Query("UPDATE notification_config SET is_encrypted = 1, encryption_key_id = :keyId, updated_at = :updatedAt WHERE id IN (:ids)")
void markConfigsAsEncrypted(List<String> ids, String keyId, long updatedAt);
// ===== UTILITY QUERIES =====
/**
* Check if configuration exists by key
*/
@Query("SELECT COUNT(*) > 0 FROM notification_config WHERE config_key = :configKey")
boolean configExistsByKey(String configKey);
/**
* Check if configuration exists by key and TimeSafari DID
*/
@Query("SELECT COUNT(*) > 0 FROM notification_config WHERE config_key = :configKey AND timesafari_did = :timesafariDid")
boolean configExistsByKeyAndDid(String configKey, String timesafariDid);
/**
* Get configuration keys by type
*/
@Query("SELECT config_key FROM notification_config WHERE config_type = :configType ORDER BY updated_at DESC")
List<String> getConfigKeysByType(String configType);
/**
* Get configuration keys by TimeSafari DID
*/
@Query("SELECT config_key FROM notification_config WHERE timesafari_did = :timesafariDid ORDER BY updated_at DESC")
List<String> getConfigKeysByTimeSafariDid(String timesafariDid);
// ===== MIGRATION QUERIES =====
/**
* Get configurations by plugin version
*/
@Query("SELECT * FROM notification_config WHERE config_key LIKE 'plugin_version_%' ORDER BY updated_at DESC")
List<NotificationConfigEntity> getConfigsByPluginVersion();
/**
* Get configurations that need migration
*/
@Query("SELECT * FROM notification_config WHERE config_key LIKE 'migration_%' ORDER BY updated_at DESC")
List<NotificationConfigEntity> getConfigsNeedingMigration();
/**
* Delete migration-related configurations
*/
@Query("DELETE FROM notification_config WHERE config_key LIKE 'migration_%'")
int deleteMigrationConfigs();
}

237
android/plugin/src/main/java/com/timesafari/dailynotification/dao/NotificationContentDao.java Normal file
View File

@@ -0,0 +1,237 @@
/**
* NotificationContentDao.java
*
* Data Access Object for NotificationContentEntity operations
* Provides efficient queries and operations for notification content management
*
* @author Matthew Raymer
* @version 1.0.0
* @since 2025-10-20
*/
package com.timesafari.dailynotification.dao;
import androidx.room.*;
import com.timesafari.dailynotification.entities.NotificationContentEntity;
import java.util.List;
/**
* Data Access Object for notification content operations
*
* Provides efficient database operations for:
* - CRUD operations on notification content
* - Plugin-specific queries and filtering
* - Performance-optimized bulk operations
* - Analytics and reporting queries
*/
@Dao
public interface NotificationContentDao {
// ===== BASIC CRUD OPERATIONS =====
/**
* Insert a new notification content entity
*/
@Insert(onConflict = OnConflictStrategy.REPLACE)
void insertNotification(NotificationContentEntity notification);
/**
* Insert multiple notification content entities
*/
@Insert(onConflict = OnConflictStrategy.REPLACE)
void insertNotifications(List<NotificationContentEntity> notifications);
/**
* Update an existing notification content entity
*/
@Update
void updateNotification(NotificationContentEntity notification);
/**
* Delete a notification content entity by ID
*/
@Query("DELETE FROM notification_content WHERE id = :id")
void deleteNotification(String id);
/**
* Delete multiple notification content entities by IDs
*/
@Query("DELETE FROM notification_content WHERE id IN (:ids)")
void deleteNotifications(List<String> ids);
// ===== QUERY OPERATIONS =====
/**
* Get notification content by ID
*/
@Query("SELECT * FROM notification_content WHERE id = :id")
NotificationContentEntity getNotificationById(String id);
/**
* Get all notification content entities
*/
@Query("SELECT * FROM notification_content ORDER BY scheduled_time ASC")
List<NotificationContentEntity> getAllNotifications();
/**
* Get notifications by TimeSafari DID
*/
@Query("SELECT * FROM notification_content WHERE timesafari_did = :timesafariDid ORDER BY scheduled_time ASC")
List<NotificationContentEntity> getNotificationsByTimeSafariDid(String timesafariDid);
/**
* Get notifications by plugin version
*/
@Query("SELECT * FROM notification_content WHERE plugin_version = :pluginVersion ORDER BY created_at DESC")
List<NotificationContentEntity> getNotificationsByPluginVersion(String pluginVersion);
/**
* Get notifications by type
*/
@Query("SELECT * FROM notification_content WHERE notification_type = :notificationType ORDER BY scheduled_time ASC")
List<NotificationContentEntity> getNotificationsByType(String notificationType);
/**
* Get notifications ready for delivery
*/
@Query("SELECT * FROM notification_content WHERE scheduled_time <= :currentTime AND delivery_status != 'delivered' ORDER BY scheduled_time ASC")
List<NotificationContentEntity> getNotificationsReadyForDelivery(long currentTime);
/**
* Get expired notifications
*/
@Query("SELECT * FROM notification_content WHERE (created_at + (ttl_seconds * 1000)) < :currentTime")
List<NotificationContentEntity> getExpiredNotifications(long currentTime);
// ===== PLUGIN-SPECIFIC QUERIES =====
/**
* Get notifications scheduled for a specific time range
*/
@Query("SELECT * FROM notification_content WHERE scheduled_time BETWEEN :startTime AND :endTime ORDER BY scheduled_time ASC")
List<NotificationContentEntity> getNotificationsInTimeRange(long startTime, long endTime);
/**
* Get notifications by delivery status
*/
@Query("SELECT * FROM notification_content WHERE delivery_status = :deliveryStatus ORDER BY scheduled_time ASC")
List<NotificationContentEntity> getNotificationsByDeliveryStatus(String deliveryStatus);
/**
* Get notifications with user interactions
*/
@Query("SELECT * FROM notification_content WHERE user_interaction_count > 0 ORDER BY last_user_interaction DESC")
List<NotificationContentEntity> getNotificationsWithUserInteractions();
/**
* Get notifications by priority
*/
@Query("SELECT * FROM notification_content WHERE priority = :priority ORDER BY scheduled_time ASC")
List<NotificationContentEntity> getNotificationsByPriority(int priority);
// ===== ANALYTICS QUERIES =====
/**
* Get notification count by type
*/
@Query("SELECT COUNT(*) FROM notification_content WHERE notification_type = :notificationType")
int getNotificationCountByType(String notificationType);
/**
* Get notification count by TimeSafari DID
*/
@Query("SELECT COUNT(*) FROM notification_content WHERE timesafari_did = :timesafariDid")
int getNotificationCountByTimeSafariDid(String timesafariDid);
/**
* Get total notification count
*/
@Query("SELECT COUNT(*) FROM notification_content")
int getTotalNotificationCount();
/**
* Get average user interaction count
*/
@Query("SELECT AVG(user_interaction_count) FROM notification_content WHERE user_interaction_count > 0")
double getAverageUserInteractionCount();
/**
* Get notifications with high interaction rates
*/
@Query("SELECT * FROM notification_content WHERE user_interaction_count > :minInteractions ORDER BY user_interaction_count DESC")
List<NotificationContentEntity> getHighInteractionNotifications(int minInteractions);
// ===== CLEANUP OPERATIONS =====
/**
* Delete expired notifications
*/
@Query("DELETE FROM notification_content WHERE (created_at + (ttl_seconds * 1000)) < :currentTime")
int deleteExpiredNotifications(long currentTime);
/**
* Delete notifications older than specified time
*/
@Query("DELETE FROM notification_content WHERE created_at < :cutoffTime")
int deleteOldNotifications(long cutoffTime);
/**
* Delete notifications by plugin version
*/
@Query("DELETE FROM notification_content WHERE plugin_version < :minVersion")
int deleteNotificationsByPluginVersion(String minVersion);
/**
* Delete notifications by TimeSafari DID
*/
@Query("DELETE FROM notification_content WHERE timesafari_did = :timesafariDid")
int deleteNotificationsByTimeSafariDid(String timesafariDid);
// ===== BULK OPERATIONS =====
/**
* Update delivery status for multiple notifications
*/
@Query("UPDATE notification_content SET delivery_status = :deliveryStatus, updated_at = :updatedAt WHERE id IN (:ids)")
void updateDeliveryStatusForNotifications(List<String> ids, String deliveryStatus, long updatedAt);
/**
* Increment delivery attempts for multiple notifications
*/
@Query("UPDATE notification_content SET delivery_attempts = delivery_attempts + 1, last_delivery_attempt = :currentTime, updated_at = :currentTime WHERE id IN (:ids)")
void incrementDeliveryAttemptsForNotifications(List<String> ids, long currentTime);
/**
* Update user interaction count for multiple notifications
*/
@Query("UPDATE notification_content SET user_interaction_count = user_interaction_count + 1, last_user_interaction = :currentTime, updated_at = :currentTime WHERE id IN (:ids)")
void incrementUserInteractionsForNotifications(List<String> ids, long currentTime);
// ===== PERFORMANCE QUERIES =====
/**
* Get notification IDs only (for lightweight operations)
*/
@Query("SELECT id FROM notification_content WHERE scheduled_time <= :currentTime AND delivery_status != 'delivered'")
List<String> getNotificationIdsReadyForDelivery(long currentTime);
/**
* Get notification count by delivery status
*/
@Query("SELECT delivery_status, COUNT(*) FROM notification_content GROUP BY delivery_status")
List<NotificationCountByStatus> getNotificationCountByDeliveryStatus();
/**
* Data class for delivery status counts
*/
class NotificationCountByStatus {
public String deliveryStatus;
public int count;
public NotificationCountByStatus(String deliveryStatus, int count) {
this.deliveryStatus = deliveryStatus;
this.count = count;
}
}
}

309
android/plugin/src/main/java/com/timesafari/dailynotification/dao/NotificationDeliveryDao.java Normal file
View File

@@ -0,0 +1,309 @@
/**
* NotificationDeliveryDao.java
*
* Data Access Object for NotificationDeliveryEntity operations
* Provides efficient queries for delivery tracking and analytics
*
* @author Matthew Raymer
* @version 1.0.0
* @since 2025-10-20
*/
package com.timesafari.dailynotification.dao;
import androidx.room.*;
import com.timesafari.dailynotification.entities.NotificationDeliveryEntity;
import java.util.List;
/**
* Data Access Object for notification delivery tracking operations
*
* Provides efficient database operations for:
* - Delivery event tracking and analytics
* - Performance monitoring and debugging
* - User interaction analysis
* - Error tracking and reporting
*/
@Dao
public interface NotificationDeliveryDao {
// ===== BASIC CRUD OPERATIONS =====
/**
* Insert a new delivery tracking entity
*/
@Insert(onConflict = OnConflictStrategy.REPLACE)
void insertDelivery(NotificationDeliveryEntity delivery);
/**
* Insert multiple delivery tracking entities
*/
@Insert(onConflict = OnConflictStrategy.REPLACE)
void insertDeliveries(List<NotificationDeliveryEntity> deliveries);
/**
* Update an existing delivery tracking entity
*/
@Update
void updateDelivery(NotificationDeliveryEntity delivery);
/**
* Delete a delivery tracking entity by ID
*/
@Query("DELETE FROM notification_delivery WHERE id = :id")
void deleteDelivery(String id);
/**
* Delete delivery tracking entities by notification ID
*/
@Query("DELETE FROM notification_delivery WHERE notification_id = :notificationId")
void deleteDeliveriesByNotificationId(String notificationId);
// ===== QUERY OPERATIONS =====
/**
* Get delivery tracking by ID
*/
@Query("SELECT * FROM notification_delivery WHERE id = :id")
NotificationDeliveryEntity getDeliveryById(String id);
/**
* Get all delivery tracking entities
*/
@Query("SELECT * FROM notification_delivery ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getAllDeliveries();
/**
* Get delivery tracking by notification ID
*/
@Query("SELECT * FROM notification_delivery WHERE notification_id = :notificationId ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getDeliveriesByNotificationId(String notificationId);
/**
* Get delivery tracking by TimeSafari DID
*/
@Query("SELECT * FROM notification_delivery WHERE timesafari_did = :timesafariDid ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getDeliveriesByTimeSafariDid(String timesafariDid);
/**
* Get delivery tracking by status
*/
@Query("SELECT * FROM notification_delivery WHERE delivery_status = :deliveryStatus ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getDeliveriesByStatus(String deliveryStatus);
/**
* Get successful deliveries
*/
@Query("SELECT * FROM notification_delivery WHERE delivery_status = 'delivered' ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getSuccessfulDeliveries();
/**
* Get failed deliveries
*/
@Query("SELECT * FROM notification_delivery WHERE delivery_status = 'failed' ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getFailedDeliveries();
/**
* Get deliveries with user interactions
*/
@Query("SELECT * FROM notification_delivery WHERE user_interaction_type IS NOT NULL ORDER BY user_interaction_timestamp DESC")
List<NotificationDeliveryEntity> getDeliveriesWithUserInteractions();
// ===== TIME-BASED QUERIES =====
/**
* Get deliveries in time range
*/
@Query("SELECT * FROM notification_delivery WHERE delivery_timestamp BETWEEN :startTime AND :endTime ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getDeliveriesInTimeRange(long startTime, long endTime);
/**
* Get recent deliveries
*/
@Query("SELECT * FROM notification_delivery WHERE delivery_timestamp > :sinceTime ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getRecentDeliveries(long sinceTime);
/**
* Get deliveries by delivery method
*/
@Query("SELECT * FROM notification_delivery WHERE delivery_method = :deliveryMethod ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getDeliveriesByMethod(String deliveryMethod);
// ===== ANALYTICS QUERIES =====
/**
* Get delivery success rate
*/
@Query("SELECT COUNT(*) FROM notification_delivery WHERE delivery_status = 'delivered'")
int getSuccessfulDeliveryCount();
/**
* Get delivery failure count
*/
@Query("SELECT COUNT(*) FROM notification_delivery WHERE delivery_status = 'failed'")
int getFailedDeliveryCount();
/**
* Get total delivery count
*/
@Query("SELECT COUNT(*) FROM notification_delivery")
int getTotalDeliveryCount();
/**
* Get average delivery duration
*/
@Query("SELECT AVG(delivery_duration_ms) FROM notification_delivery WHERE delivery_duration_ms > 0")
double getAverageDeliveryDuration();
/**
* Get user interaction count
*/
@Query("SELECT COUNT(*) FROM notification_delivery WHERE user_interaction_type IS NOT NULL")
int getUserInteractionCount();
/**
* Get average user interaction duration
*/
@Query("SELECT AVG(user_interaction_duration_ms) FROM notification_delivery WHERE user_interaction_duration_ms > 0")
double getAverageUserInteractionDuration();
// ===== ERROR ANALYSIS QUERIES =====
/**
* Get deliveries by error code
*/
@Query("SELECT * FROM notification_delivery WHERE error_code = :errorCode ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getDeliveriesByErrorCode(String errorCode);
/**
* Get most common error codes
*/
@Query("SELECT error_code, COUNT(*) as count FROM notification_delivery WHERE error_code IS NOT NULL GROUP BY error_code ORDER BY count DESC")
List<ErrorCodeCount> getErrorCodeCounts();
/**
* Get deliveries with specific error messages
*/
@Query("SELECT * FROM notification_delivery WHERE error_message LIKE :errorPattern ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getDeliveriesByErrorPattern(String errorPattern);
// ===== PERFORMANCE ANALYSIS QUERIES =====
/**
* Get deliveries by battery level
*/
@Query("SELECT * FROM notification_delivery WHERE battery_level BETWEEN :minBattery AND :maxBattery ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getDeliveriesByBatteryLevel(int minBattery, int maxBattery);
/**
* Get deliveries in doze mode
*/
@Query("SELECT * FROM notification_delivery WHERE doze_mode_active = 1 ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getDeliveriesInDozeMode();
/**
* Get deliveries without exact alarm permission
*/
@Query("SELECT * FROM notification_delivery WHERE exact_alarm_permission = 0 ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getDeliveriesWithoutExactAlarmPermission();
/**
* Get deliveries without notification permission
*/
@Query("SELECT * FROM notification_delivery WHERE notification_permission = 0 ORDER BY delivery_timestamp DESC")
List<NotificationDeliveryEntity> getDeliveriesWithoutNotificationPermission();
// ===== CLEANUP OPERATIONS =====
/**
* Delete old delivery tracking data
*/
@Query("DELETE FROM notification_delivery WHERE delivery_timestamp < :cutoffTime")
int deleteOldDeliveries(long cutoffTime);
/**
* Delete delivery tracking by TimeSafari DID
*/
@Query("DELETE FROM notification_delivery WHERE timesafari_did = :timesafariDid")
int deleteDeliveriesByTimeSafariDid(String timesafariDid);
/**
* Delete failed deliveries older than specified time
*/
@Query("DELETE FROM notification_delivery WHERE delivery_status = 'failed' AND delivery_timestamp < :cutoffTime")
int deleteOldFailedDeliveries(long cutoffTime);
// ===== BULK OPERATIONS =====
/**
* Update delivery status for multiple deliveries
*/
@Query("UPDATE notification_delivery SET delivery_status = :deliveryStatus WHERE id IN (:ids)")
void updateDeliveryStatusForDeliveries(List<String> ids, String deliveryStatus);
/**
* Record user interactions for multiple deliveries
*/
@Query("UPDATE notification_delivery SET user_interaction_type = :interactionType, user_interaction_timestamp = :timestamp, user_interaction_duration_ms = :duration WHERE id IN (:ids)")
void recordUserInteractionsForDeliveries(List<String> ids, String interactionType, long timestamp, long duration);
// ===== REPORTING QUERIES =====
/**
* Get delivery statistics by day
*/
@Query("SELECT DATE(delivery_timestamp/1000, 'unixepoch') as day, COUNT(*) as count, SUM(CASE WHEN delivery_status = 'delivered' THEN 1 ELSE 0 END) as successful FROM notification_delivery GROUP BY DATE(delivery_timestamp/1000, 'unixepoch') ORDER BY day DESC")
List<DailyDeliveryStats> getDailyDeliveryStats();
/**
* Get delivery statistics by hour
*/
@Query("SELECT strftime('%H', delivery_timestamp/1000, 'unixepoch') as hour, COUNT(*) as count, SUM(CASE WHEN delivery_status = 'delivered' THEN 1 ELSE 0 END) as successful FROM notification_delivery GROUP BY strftime('%H', delivery_timestamp/1000, 'unixepoch') ORDER BY hour")
List<HourlyDeliveryStats> getHourlyDeliveryStats();
// ===== DATA CLASSES FOR COMPLEX QUERIES =====
/**
* Data class for error code counts
*/
class ErrorCodeCount {
public String errorCode;
public int count;
public ErrorCodeCount(String errorCode, int count) {
this.errorCode = errorCode;
this.count = count;
}
}
/**
* Data class for daily delivery statistics
*/
class DailyDeliveryStats {
public String day;
public int count;
public int successful;
public DailyDeliveryStats(String day, int count, int successful) {
this.day = day;
this.count = count;
this.successful = successful;
}
}
/**
* Data class for hourly delivery statistics
*/
class HourlyDeliveryStats {
public String hour;
public int count;
public int successful;
public HourlyDeliveryStats(String hour, int count, int successful) {
this.hour = hour;
this.count = count;
this.successful = successful;
}
}
}

300
android/plugin/src/main/java/com/timesafari/dailynotification/database/DailyNotificationDatabase.java Normal file
View File

@@ -0,0 +1,300 @@
/**
* DailyNotificationDatabase.java
*
* Room database for the DailyNotification plugin
* Provides centralized data management with encryption, retention policies, and migration support
*
* @author Matthew Raymer
* @version 1.0.0
* @since 2025-10-20
*/
package com.timesafari.dailynotification.database;
import android.content.Context;
import androidx.room.*;
import androidx.room.migration.Migration;
import androidx.sqlite.db.SupportSQLiteDatabase;
import com.timesafari.dailynotification.dao.NotificationContentDao;
import com.timesafari.dailynotification.dao.NotificationDeliveryDao;
import com.timesafari.dailynotification.dao.NotificationConfigDao;
import com.timesafari.dailynotification.entities.NotificationContentEntity;
import com.timesafari.dailynotification.entities.NotificationDeliveryEntity;
import com.timesafari.dailynotification.entities.NotificationConfigEntity;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Room database for the DailyNotification plugin
*
* This database provides:
* - Centralized data management for all plugin data
* - Encryption support for sensitive information
* - Automatic retention policy enforcement
* - Migration support for schema changes
* - Performance optimization with proper indexing
* - Background thread execution for database operations
*/
@Database(
entities = {
NotificationContentEntity.class,
NotificationDeliveryEntity.class,
NotificationConfigEntity.class
},
version = 1,
exportSchema = false
)
public abstract class DailyNotificationDatabase extends RoomDatabase {
private static final String TAG = "DailyNotificationDatabase";
private static final String DATABASE_NAME = "daily_notification_plugin.db";
// Singleton instance
private static volatile DailyNotificationDatabase INSTANCE;
// Thread pool for database operations
private static final int NUMBER_OF_THREADS = 4;
public static final ExecutorService databaseWriteExecutor = Executors.newFixedThreadPool(NUMBER_OF_THREADS);
// DAO accessors
public abstract NotificationContentDao notificationContentDao();
public abstract NotificationDeliveryDao notificationDeliveryDao();
public abstract NotificationConfigDao notificationConfigDao();
/**
* Get singleton instance of the database
*
* @param context Application context
* @return Database instance
*/
public static DailyNotificationDatabase getInstance(Context context) {
if (INSTANCE == null) {
synchronized (DailyNotificationDatabase.class) {
if (INSTANCE == null) {
INSTANCE = Room.databaseBuilder(
context.getApplicationContext(),
DailyNotificationDatabase.class,
DATABASE_NAME
)
.addCallback(roomCallback)
.addMigrations(MIGRATION_1_2) // Add future migrations here
.build();
}
}
}
return INSTANCE;
}
/**
* Room database callback for initialization and cleanup
*/
private static RoomDatabase.Callback roomCallback = new RoomDatabase.Callback() {
@Override
public void onCreate(SupportSQLiteDatabase db) {
super.onCreate(db);
// Initialize database with default data if needed
databaseWriteExecutor.execute(() -> {
// Populate with default configurations
populateDefaultConfigurations();
});
}
@Override
public void onOpen(SupportSQLiteDatabase db) {
super.onOpen(db);
// Perform any necessary setup when database is opened
databaseWriteExecutor.execute(() -> {
// Clean up expired data
cleanupExpiredData();
});
}
};
/**
* Populate database with default configurations
*/
private static void populateDefaultConfigurations() {
if (INSTANCE == null) return;
NotificationConfigDao configDao = INSTANCE.notificationConfigDao();
// Default plugin settings
NotificationConfigEntity defaultSettings = new NotificationConfigEntity(
"default_plugin_settings",
null, // Global settings
"plugin_setting",
"default_settings",
"{}",
"json"
);
defaultSettings.setTypedValue("{\"version\":\"1.0.0\",\"retention_days\":7,\"max_notifications\":100}");
configDao.insertConfig(defaultSettings);
// Default performance settings
NotificationConfigEntity performanceSettings = new NotificationConfigEntity(
"default_performance_settings",
null, // Global settings
"performance_setting",
"performance_config",
"{}",
"json"
);
performanceSettings.setTypedValue("{\"max_concurrent_deliveries\":5,\"delivery_timeout_ms\":30000,\"retry_attempts\":3}");
configDao.insertConfig(performanceSettings);
}
/**
* Clean up expired data from all tables
*/
private static void cleanupExpiredData() {
if (INSTANCE == null) return;
long currentTime = System.currentTimeMillis();
// Clean up expired notifications
NotificationContentDao contentDao = INSTANCE.notificationContentDao();
int deletedNotifications = contentDao.deleteExpiredNotifications(currentTime);
// Clean up old delivery tracking data (keep for 30 days)
NotificationDeliveryDao deliveryDao = INSTANCE.notificationDeliveryDao();
long deliveryCutoff = currentTime - (30L * 24 * 60 * 60 * 1000); // 30 days ago
int deletedDeliveries = deliveryDao.deleteOldDeliveries(deliveryCutoff);
// Clean up expired configurations
NotificationConfigDao configDao = INSTANCE.notificationConfigDao();
int deletedConfigs = configDao.deleteExpiredConfigs(currentTime);
android.util.Log.d(TAG, "Cleanup completed: " + deletedNotifications + " notifications, " +
deletedDeliveries + " deliveries, " + deletedConfigs + " configs");
}
/**
* Migration from version 1 to 2
* Add new columns for enhanced functionality
*/
static final Migration MIGRATION_1_2 = new Migration(1, 2) {
@Override
public void migrate(SupportSQLiteDatabase database) {
// Add new columns to notification_content table
database.execSQL("ALTER TABLE notification_content ADD COLUMN analytics_data TEXT");
database.execSQL("ALTER TABLE notification_content ADD COLUMN priority_level INTEGER DEFAULT 0");
// Add new columns to notification_delivery table
database.execSQL("ALTER TABLE notification_delivery ADD COLUMN delivery_metadata TEXT");
database.execSQL("ALTER TABLE notification_delivery ADD COLUMN performance_metrics TEXT");
// Add new columns to notification_config table
database.execSQL("ALTER TABLE notification_config ADD COLUMN config_category TEXT DEFAULT 'general'");
database.execSQL("ALTER TABLE notification_config ADD COLUMN config_priority INTEGER DEFAULT 0");
}
};
/**
* Close the database connection
* Should be called when the plugin is being destroyed
*/
public static void closeDatabase() {
if (INSTANCE != null) {
INSTANCE.close();
INSTANCE = null;
}
}
/**
* Clear all data from the database
* Use with caution - this will delete all plugin data
*/
public static void clearAllData() {
if (INSTANCE == null) return;
databaseWriteExecutor.execute(() -> {
NotificationContentDao contentDao = INSTANCE.notificationContentDao();
NotificationDeliveryDao deliveryDao = INSTANCE.notificationDeliveryDao();
NotificationConfigDao configDao = INSTANCE.notificationConfigDao();
// Clear all tables
contentDao.deleteNotificationsByPluginVersion("0"); // Delete all
deliveryDao.deleteDeliveriesByTimeSafariDid("all"); // Delete all
configDao.deleteConfigsByType("all"); // Delete all
android.util.Log.d(TAG, "All plugin data cleared");
});
}
/**
* Get database statistics
*
* @return Database statistics as a formatted string
*/
public static String getDatabaseStats() {
if (INSTANCE == null) return "Database not initialized";
NotificationContentDao contentDao = INSTANCE.notificationContentDao();
NotificationDeliveryDao deliveryDao = INSTANCE.notificationDeliveryDao();
NotificationConfigDao configDao = INSTANCE.notificationConfigDao();
int notificationCount = contentDao.getTotalNotificationCount();
int deliveryCount = deliveryDao.getTotalDeliveryCount();
int configCount = configDao.getTotalConfigCount();
return String.format("Database Stats:\n" +
" Notifications: %d\n" +
" Deliveries: %d\n" +
" Configurations: %d\n" +
" Total Records: %d",
notificationCount, deliveryCount, configCount,
notificationCount + deliveryCount + configCount);
}
/**
* Perform database maintenance
* Includes cleanup, optimization, and integrity checks
*/
public static void performMaintenance() {
if (INSTANCE == null) return;
databaseWriteExecutor.execute(() -> {
long startTime = System.currentTimeMillis();
// Clean up expired data
cleanupExpiredData();
// Additional maintenance tasks can be added here
// - Vacuum database
// - Analyze tables for query optimization
// - Check database integrity
long duration = System.currentTimeMillis() - startTime;
android.util.Log.d(TAG, "Database maintenance completed in " + duration + "ms");
});
}
/**
* Export database data for backup or migration
*
* @return Database export as JSON string
*/
public static String exportDatabaseData() {
if (INSTANCE == null) return "{}";
// This would typically serialize all data to JSON
// Implementation depends on specific export requirements
return "{\"export\":\"not_implemented_yet\"}";
}
/**
* Import database data from backup
*
* @param jsonData JSON data to import
* @return Success status
*/
public static boolean importDatabaseData(String jsonData) {
if (INSTANCE == null || jsonData == null) return false;
// This would typically deserialize JSON data and insert into database
// Implementation depends on specific import requirements
return false;
}
}

248
android/plugin/src/main/java/com/timesafari/dailynotification/entities/NotificationConfigEntity.java Normal file
View File

@@ -0,0 +1,248 @@
/**
* NotificationConfigEntity.java
*
* Room entity for storing plugin configuration and user preferences
* Manages settings, preferences, and plugin state across sessions
*
* @author Matthew Raymer
* @version 1.0.0
* @since 2025-10-20
*/
package com.timesafari.dailynotification.entities;
import androidx.annotation.NonNull;
import androidx.room.ColumnInfo;
import androidx.room.Entity;
import androidx.room.Index;
import androidx.room.PrimaryKey;
/**
* Room entity for storing plugin configuration and user preferences
*
* This entity manages:
* - User notification preferences
* - Plugin settings and state
* - TimeSafari integration configuration
* - Performance and behavior tuning
*/
@Entity(
tableName = "notification_config",
indices = {
@Index(value = {"timesafari_did"}),
@Index(value = {"config_type"}),
@Index(value = {"updated_at"})
}
)
public class NotificationConfigEntity {
@PrimaryKey
@NonNull
@ColumnInfo(name = "id")
public String id;
@ColumnInfo(name = "timesafari_did")
public String timesafariDid;
@ColumnInfo(name = "config_type")
public String configType;
@ColumnInfo(name = "config_key")
public String configKey;
@ColumnInfo(name = "config_value")
public String configValue;
@ColumnInfo(name = "config_data_type")
public String configDataType;
@ColumnInfo(name = "is_encrypted")
public boolean isEncrypted;
@ColumnInfo(name = "encryption_key_id")
public String encryptionKeyId;
@ColumnInfo(name = "created_at")
public long createdAt;
@ColumnInfo(name = "updated_at")
public long updatedAt;
@ColumnInfo(name = "ttl_seconds")
public long ttlSeconds;
@ColumnInfo(name = "is_active")
public boolean isActive;
@ColumnInfo(name = "metadata")
public String metadata;
/**
* Default constructor for Room
*/
public NotificationConfigEntity() {
this.createdAt = System.currentTimeMillis();
this.updatedAt = System.currentTimeMillis();
this.isEncrypted = false;
this.isActive = true;
this.ttlSeconds = 30 * 24 * 60 * 60; // Default 30 days
}
/**
* Constructor for configuration entries
*/
public NotificationConfigEntity(@NonNull String id, String timesafariDid,
String configType, String configKey,
String configValue, String configDataType) {
this();
this.id = id;
this.timesafariDid = timesafariDid;
this.configType = configType;
this.configKey = configKey;
this.configValue = configValue;
this.configDataType = configDataType;
}
/**
* Update the configuration value and timestamp
*/
public void updateValue(String newValue) {
this.configValue = newValue;
this.updatedAt = System.currentTimeMillis();
}
/**
* Mark configuration as encrypted
*/
public void setEncrypted(String keyId) {
this.isEncrypted = true;
this.encryptionKeyId = keyId;
touch();
}
/**
* Update the last updated timestamp
*/
public void touch() {
this.updatedAt = System.currentTimeMillis();
}
/**
* Check if this configuration has expired
*/
public boolean isExpired() {
long expirationTime = createdAt + (ttlSeconds * 1000);
return System.currentTimeMillis() > expirationTime;
}
/**
* Get time until expiration in milliseconds
*/
public long getTimeUntilExpiration() {
long expirationTime = createdAt + (ttlSeconds * 1000);
return Math.max(0, expirationTime - System.currentTimeMillis());
}
/**
* Get configuration age in milliseconds
*/
public long getConfigAge() {
return System.currentTimeMillis() - createdAt;
}
/**
* Get time since last update in milliseconds
*/
public long getTimeSinceUpdate() {
return System.currentTimeMillis() - updatedAt;
}
/**
* Parse configuration value based on data type
*/
public Object getParsedValue() {
if (configValue == null) {
return null;
}
switch (configDataType) {
case "boolean":
return Boolean.parseBoolean(configValue);
case "integer":
try {
return Integer.parseInt(configValue);
} catch (NumberFormatException e) {
return 0;
}
case "long":
try {
return Long.parseLong(configValue);
} catch (NumberFormatException e) {
return 0L;
}
case "float":
try {
return Float.parseFloat(configValue);
} catch (NumberFormatException e) {
return 0.0f;
}
case "double":
try {
return Double.parseDouble(configValue);
} catch (NumberFormatException e) {
return 0.0;
}
case "json":
case "string":
default:
return configValue;
}
}
/**
* Set configuration value with proper data type
*/
public void setTypedValue(Object value) {
if (value == null) {
this.configValue = null;
this.configDataType = "string";
} else if (value instanceof Boolean) {
this.configValue = value.toString();
this.configDataType = "boolean";
} else if (value instanceof Integer) {
this.configValue = value.toString();
this.configDataType = "integer";
} else if (value instanceof Long) {
this.configValue = value.toString();
this.configDataType = "long";
} else if (value instanceof Float) {
this.configValue = value.toString();
this.configDataType = "float";
} else if (value instanceof Double) {
this.configValue = value.toString();
this.configDataType = "double";
} else if (value instanceof String) {
this.configValue = (String) value;
this.configDataType = "string";
} else {
// For complex objects, serialize as JSON
this.configValue = value.toString();
this.configDataType = "json";
}
touch();
}
@Override
public String toString() {
return "NotificationConfigEntity{" +
"id='" + id + '\'' +
", timesafariDid='" + timesafariDid + '\'' +
", configType='" + configType + '\'' +
", configKey='" + configKey + '\'' +
", configDataType='" + configDataType + '\'' +
", isEncrypted=" + isEncrypted +
", isActive=" + isActive +
", isExpired=" + isExpired() +
'}';
}
}

212
android/plugin/src/main/java/com/timesafari/dailynotification/entities/NotificationContentEntity.java Normal file
View File

@@ -0,0 +1,212 @@
/**
* NotificationContentEntity.java
*
* Room entity for storing notification content with plugin-specific fields
* Includes encryption support, TTL management, and TimeSafari integration
*
* @author Matthew Raymer
* @version 1.0.0
* @since 2025-10-20
*/
package com.timesafari.dailynotification.entities;
import androidx.annotation.NonNull;
import androidx.room.ColumnInfo;
import androidx.room.Entity;
import androidx.room.Index;
import androidx.room.PrimaryKey;
/**
* Room entity representing notification content stored in the plugin database
*
* This entity stores notification data with plugin-specific fields including:
* - Plugin version tracking for migration support
* - TimeSafari DID integration for user identification
* - Encryption support for sensitive content
* - TTL management for automatic cleanup
* - Analytics fields for usage tracking
*/
@Entity(
tableName = "notification_content",
indices = {
@Index(value = {"timesafari_did"}),
@Index(value = {"notification_type"}),
@Index(value = {"scheduled_time"}),
@Index(value = {"created_at"}),
@Index(value = {"plugin_version"})
}
)
public class NotificationContentEntity {
@PrimaryKey
@NonNull
@ColumnInfo(name = "id")
public String id;
@ColumnInfo(name = "plugin_version")
public String pluginVersion;
@ColumnInfo(name = "timesafari_did")
public String timesafariDid;
@ColumnInfo(name = "notification_type")
public String notificationType;
@ColumnInfo(name = "title")
public String title;
@ColumnInfo(name = "body")
public String body;
@ColumnInfo(name = "scheduled_time")
public long scheduledTime;
@ColumnInfo(name = "timezone")
public String timezone;
@ColumnInfo(name = "priority")
public int priority;
@ColumnInfo(name = "vibration_enabled")
public boolean vibrationEnabled;
@ColumnInfo(name = "sound_enabled")
public boolean soundEnabled;
@ColumnInfo(name = "media_url")
public String mediaUrl;
@ColumnInfo(name = "encrypted_content")
public String encryptedContent;
@ColumnInfo(name = "encryption_key_id")
public String encryptionKeyId;
@ColumnInfo(name = "created_at")
public long createdAt;
@ColumnInfo(name = "updated_at")
public long updatedAt;
@ColumnInfo(name = "ttl_seconds")
public long ttlSeconds;
@ColumnInfo(name = "delivery_status")
public String deliveryStatus;
@ColumnInfo(name = "delivery_attempts")
public int deliveryAttempts;
@ColumnInfo(name = "last_delivery_attempt")
public long lastDeliveryAttempt;
@ColumnInfo(name = "user_interaction_count")
public int userInteractionCount;
@ColumnInfo(name = "last_user_interaction")
public long lastUserInteraction;
@ColumnInfo(name = "metadata")
public String metadata;
/**
* Default constructor for Room
*/
public NotificationContentEntity() {
this.createdAt = System.currentTimeMillis();
this.updatedAt = System.currentTimeMillis();
this.deliveryAttempts = 0;
this.userInteractionCount = 0;
this.ttlSeconds = 7 * 24 * 60 * 60; // Default 7 days
}
/**
* Constructor with required fields
*/
public NotificationContentEntity(@NonNull String id, String pluginVersion, String timesafariDid,
String notificationType, String title, String body,
long scheduledTime, String timezone) {
this();
this.id = id;
this.pluginVersion = pluginVersion;
this.timesafariDid = timesafariDid;
this.notificationType = notificationType;
this.title = title;
this.body = body;
this.scheduledTime = scheduledTime;
this.timezone = timezone;
}
/**
* Check if this notification has expired based on TTL
*/
public boolean isExpired() {
long expirationTime = createdAt + (ttlSeconds * 1000);
return System.currentTimeMillis() > expirationTime;
}
/**
* Check if this notification is ready for delivery
*/
public boolean isReadyForDelivery() {
return System.currentTimeMillis() >= scheduledTime && !isExpired();
}
/**
* Update the last updated timestamp
*/
public void touch() {
this.updatedAt = System.currentTimeMillis();
}
/**
* Increment delivery attempts and update timestamp
*/
public void recordDeliveryAttempt() {
this.deliveryAttempts++;
this.lastDeliveryAttempt = System.currentTimeMillis();
touch();
}
/**
* Record user interaction
*/
public void recordUserInteraction() {
this.userInteractionCount++;
this.lastUserInteraction = System.currentTimeMillis();
touch();
}
/**
* Get time until expiration in milliseconds
*/
public long getTimeUntilExpiration() {
long expirationTime = createdAt + (ttlSeconds * 1000);
return Math.max(0, expirationTime - System.currentTimeMillis());
}
/**
* Get time until scheduled delivery in milliseconds
*/
public long getTimeUntilDelivery() {
return Math.max(0, scheduledTime - System.currentTimeMillis());
}
@Override
public String toString() {
return "NotificationContentEntity{" +
"id='" + id + '\'' +
", pluginVersion='" + pluginVersion + '\'' +
", timesafariDid='" + timesafariDid + '\'' +
", notificationType='" + notificationType + '\'' +
", title='" + title + '\'' +
", scheduledTime=" + scheduledTime +
", deliveryStatus='" + deliveryStatus + '\'' +
", deliveryAttempts=" + deliveryAttempts +
", userInteractionCount=" + userInteractionCount +
", isExpired=" + isExpired() +
", isReadyForDelivery=" + isReadyForDelivery() +
'}';
}
}

223
android/plugin/src/main/java/com/timesafari/dailynotification/entities/NotificationDeliveryEntity.java Normal file
View File

@@ -0,0 +1,223 @@
/**
* NotificationDeliveryEntity.java
*
* Room entity for tracking notification delivery events and analytics
* Provides detailed tracking of delivery attempts, failures, and user interactions
*
* @author Matthew Raymer
* @version 1.0.0
* @since 2025-10-20
*/
package com.timesafari.dailynotification.entities;
import androidx.annotation.NonNull;
import androidx.room.ColumnInfo;
import androidx.room.Entity;
import androidx.room.ForeignKey;
import androidx.room.Index;
import androidx.room.PrimaryKey;
/**
* Room entity for tracking notification delivery events
*
* This entity provides detailed analytics and tracking for:
* - Delivery attempts and their outcomes
* - User interaction patterns
* - Performance metrics
* - Error tracking and debugging
*/
@Entity(
tableName = "notification_delivery",
foreignKeys = @ForeignKey(
entity = NotificationContentEntity.class,
parentColumns = "id",
childColumns = "notification_id",
onDelete = ForeignKey.CASCADE
),
indices = {
@Index(value = {"notification_id"}),
@Index(value = {"delivery_timestamp"}),
@Index(value = {"delivery_status"}),
@Index(value = {"user_interaction_type"}),
@Index(value = {"timesafari_did"})
}
)
public class NotificationDeliveryEntity {
@PrimaryKey
@NonNull
@ColumnInfo(name = "id")
public String id;
@ColumnInfo(name = "notification_id")
public String notificationId;
@ColumnInfo(name = "timesafari_did")
public String timesafariDid;
@ColumnInfo(name = "delivery_timestamp")
public long deliveryTimestamp;
@ColumnInfo(name = "delivery_status")
public String deliveryStatus;
@ColumnInfo(name = "delivery_method")
public String deliveryMethod;
@ColumnInfo(name = "delivery_attempt_number")
public int deliveryAttemptNumber;
@ColumnInfo(name = "delivery_duration_ms")
public long deliveryDurationMs;
@ColumnInfo(name = "user_interaction_type")
public String userInteractionType;
@ColumnInfo(name = "user_interaction_timestamp")
public long userInteractionTimestamp;
@ColumnInfo(name = "user_interaction_duration_ms")
public long userInteractionDurationMs;
@ColumnInfo(name = "error_code")
public String errorCode;
@ColumnInfo(name = "error_message")
public String errorMessage;
@ColumnInfo(name = "device_info")
public String deviceInfo;
@ColumnInfo(name = "network_info")
public String networkInfo;
@ColumnInfo(name = "battery_level")
public int batteryLevel;
@ColumnInfo(name = "doze_mode_active")
public boolean dozeModeActive;
@ColumnInfo(name = "exact_alarm_permission")
public boolean exactAlarmPermission;
@ColumnInfo(name = "notification_permission")
public boolean notificationPermission;
@ColumnInfo(name = "metadata")
public String metadata;
/**
* Default constructor for Room
*/
public NotificationDeliveryEntity() {
this.deliveryTimestamp = System.currentTimeMillis();
this.deliveryAttemptNumber = 1;
this.deliveryDurationMs = 0;
this.userInteractionDurationMs = 0;
this.batteryLevel = -1;
this.dozeModeActive = false;
this.exactAlarmPermission = false;
this.notificationPermission = false;
}
/**
* Constructor for delivery tracking
*/
public NotificationDeliveryEntity(@NonNull String id, String notificationId,
String timesafariDid, String deliveryStatus,
String deliveryMethod) {
this();
this.id = id;
this.notificationId = notificationId;
this.timesafariDid = timesafariDid;
this.deliveryStatus = deliveryStatus;
this.deliveryMethod = deliveryMethod;
}
/**
* Record successful delivery
*/
public void recordSuccessfulDelivery(long durationMs) {
this.deliveryStatus = "delivered";
this.deliveryDurationMs = durationMs;
this.deliveryTimestamp = System.currentTimeMillis();
}
/**
* Record failed delivery
*/
public void recordFailedDelivery(String errorCode, String errorMessage, long durationMs) {
this.deliveryStatus = "failed";
this.errorCode = errorCode;
this.errorMessage = errorMessage;
this.deliveryDurationMs = durationMs;
this.deliveryTimestamp = System.currentTimeMillis();
}
/**
* Record user interaction
*/
public void recordUserInteraction(String interactionType, long durationMs) {
this.userInteractionType = interactionType;
this.userInteractionTimestamp = System.currentTimeMillis();
this.userInteractionDurationMs = durationMs;
}
/**
* Set device context information
*/
public void setDeviceContext(int batteryLevel, boolean dozeModeActive,
boolean exactAlarmPermission, boolean notificationPermission) {
this.batteryLevel = batteryLevel;
this.dozeModeActive = dozeModeActive;
this.exactAlarmPermission = exactAlarmPermission;
this.notificationPermission = notificationPermission;
}
/**
* Check if this delivery was successful
*/
public boolean isSuccessful() {
return "delivered".equals(deliveryStatus);
}
/**
* Check if this delivery had user interaction
*/
public boolean hasUserInteraction() {
return userInteractionType != null && !userInteractionType.isEmpty();
}
/**
* Get delivery age in milliseconds
*/
public long getDeliveryAge() {
return System.currentTimeMillis() - deliveryTimestamp;
}
/**
* Get time since user interaction in milliseconds
*/
public long getTimeSinceUserInteraction() {
if (userInteractionTimestamp == 0) {
return -1; // No interaction recorded
}
return System.currentTimeMillis() - userInteractionTimestamp;
}
@Override
public String toString() {
return "NotificationDeliveryEntity{" +
"id='" + id + '\'' +
", notificationId='" + notificationId + '\'' +
", deliveryStatus='" + deliveryStatus + '\'' +
", deliveryMethod='" + deliveryMethod + '\'' +
", deliveryAttemptNumber=" + deliveryAttemptNumber +
", userInteractionType='" + userInteractionType + '\'' +
", errorCode='" + errorCode + '\'' +
", isSuccessful=" + isSuccessful() +
", hasUserInteraction=" + hasUserInteraction() +
'}';
}
}

538
android/plugin/src/main/java/com/timesafari/dailynotification/storage/DailyNotificationStorageRoom.java Normal file
View File

@@ -0,0 +1,538 @@
/**
* DailyNotificationStorageRoom.java
*
* Room-based storage implementation for the DailyNotification plugin
* Provides enterprise-grade data management with encryption, retention policies, and analytics
*
* @author Matthew Raymer
* @version 1.0.0
* @since 2025-10-20
*/
package com.timesafari.dailynotification.storage;
import android.content.Context;
import android.util.Log;
import com.timesafari.dailynotification.database.DailyNotificationDatabase;
import com.timesafari.dailynotification.dao.NotificationContentDao;
import com.timesafari.dailynotification.dao.NotificationDeliveryDao;
import com.timesafari.dailynotification.dao.NotificationConfigDao;
import com.timesafari.dailynotification.entities.NotificationContentEntity;
import com.timesafari.dailynotification.entities.NotificationDeliveryEntity;
import com.timesafari.dailynotification.entities.NotificationConfigEntity;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Room-based storage implementation for the DailyNotification plugin
*
* This class provides:
* - Enterprise-grade data persistence with Room database
* - Encryption support for sensitive notification content
* - Automatic retention policy enforcement
* - Comprehensive analytics and reporting
* - Background thread execution for all database operations
* - Migration support from SharedPreferences-based storage
*/
public class DailyNotificationStorageRoom {
private static final String TAG = "DailyNotificationStorageRoom";
// Database and DAOs
private DailyNotificationDatabase database;
private NotificationContentDao contentDao;
private NotificationDeliveryDao deliveryDao;
private NotificationConfigDao configDao;
// Thread pool for database operations
private final ExecutorService executorService;
// Plugin version for migration tracking
private static final String PLUGIN_VERSION = "1.0.0";
/**
* Constructor
*
* @param context Application context
*/
public DailyNotificationStorageRoom(Context context) {
this.database = DailyNotificationDatabase.getInstance(context);
this.contentDao = database.notificationContentDao();
this.deliveryDao = database.notificationDeliveryDao();
this.configDao = database.notificationConfigDao();
this.executorService = Executors.newFixedThreadPool(4);
Log.d(TAG, "Room-based storage initialized");
}
// ===== NOTIFICATION CONTENT OPERATIONS =====
/**
* Save notification content to Room database
*
* @param content Notification content to save
* @return CompletableFuture with success status
*/
public CompletableFuture<Boolean> saveNotificationContent(NotificationContentEntity content) {
return CompletableFuture.supplyAsync(() -> {
try {
content.pluginVersion = PLUGIN_VERSION;
content.touch();
contentDao.insertNotification(content);
Log.d(TAG, "Saved notification content: " + content.id);
return true;
} catch (Exception e) {
Log.e(TAG, "Failed to save notification content: " + content.id, e);
return false;
}
}, executorService);
}
/**
* Get notification content by ID
*
* @param id Notification ID
* @return CompletableFuture with notification content
*/
public CompletableFuture<NotificationContentEntity> getNotificationContent(String id) {
return CompletableFuture.supplyAsync(() -> {
try {
return contentDao.getNotificationById(id);
} catch (Exception e) {
Log.e(TAG, "Failed to get notification content: " + id, e);
return null;
}
}, executorService);
}
/**
* Get all notification content for a TimeSafari user
*
* @param timesafariDid TimeSafari DID
* @return CompletableFuture with list of notifications
*/
public CompletableFuture<List<NotificationContentEntity>> getNotificationsByTimeSafariDid(String timesafariDid) {
return CompletableFuture.supplyAsync(() -> {
try {
return contentDao.getNotificationsByTimeSafariDid(timesafariDid);
} catch (Exception e) {
Log.e(TAG, "Failed to get notifications for DID: " + timesafariDid, e);
return null;
}
}, executorService);
}
/**
* Get notifications ready for delivery
*
* @return CompletableFuture with list of ready notifications
*/
public CompletableFuture<List<NotificationContentEntity>> getNotificationsReadyForDelivery() {
return CompletableFuture.supplyAsync(() -> {
try {
long currentTime = System.currentTimeMillis();
return contentDao.getNotificationsReadyForDelivery(currentTime);
} catch (Exception e) {
Log.e(TAG, "Failed to get notifications ready for delivery", e);
return null;
}
}, executorService);
}
/**
* Update notification delivery status
*
* @param id Notification ID
* @param deliveryStatus New delivery status
* @return CompletableFuture with success status
*/
public CompletableFuture<Boolean> updateNotificationDeliveryStatus(String id, String deliveryStatus) {
return CompletableFuture.supplyAsync(() -> {
try {
NotificationContentEntity content = contentDao.getNotificationById(id);
if (content != null) {
content.deliveryStatus = deliveryStatus;
content.touch();
contentDao.updateNotification(content);
Log.d(TAG, "Updated delivery status for notification: " + id + " to " + deliveryStatus);
return true;
}
return false;
} catch (Exception e) {
Log.e(TAG, "Failed to update delivery status for notification: " + id, e);
return false;
}
}, executorService);
}
/**
* Record user interaction with notification
*
* @param id Notification ID
* @return CompletableFuture with success status
*/
public CompletableFuture<Boolean> recordUserInteraction(String id) {
return CompletableFuture.supplyAsync(() -> {
try {
NotificationContentEntity content = contentDao.getNotificationById(id);
if (content != null) {
content.recordUserInteraction();
contentDao.updateNotification(content);
Log.d(TAG, "Recorded user interaction for notification: " + id);
return true;
}
return false;
} catch (Exception e) {
Log.e(TAG, "Failed to record user interaction for notification: " + id, e);
return false;
}
}, executorService);
}
// ===== DELIVERY TRACKING OPERATIONS =====
/**
* Record notification delivery attempt
*
* @param delivery Delivery tracking entity
* @return CompletableFuture with success status
*/
public CompletableFuture<Boolean> recordDeliveryAttempt(NotificationDeliveryEntity delivery) {
return CompletableFuture.supplyAsync(() -> {
try {
deliveryDao.insertDelivery(delivery);
Log.d(TAG, "Recorded delivery attempt: " + delivery.id);
return true;
} catch (Exception e) {
Log.e(TAG, "Failed to record delivery attempt: " + delivery.id, e);
return false;
}
}, executorService);
}
/**
* Get delivery history for a notification
*
* @param notificationId Notification ID
* @return CompletableFuture with delivery history
*/
public CompletableFuture<List<NotificationDeliveryEntity>> getDeliveryHistory(String notificationId) {
return CompletableFuture.supplyAsync(() -> {
try {
return deliveryDao.getDeliveriesByNotificationId(notificationId);
} catch (Exception e) {
Log.e(TAG, "Failed to get delivery history for notification: " + notificationId, e);
return null;
}
}, executorService);
}
/**
* Get delivery analytics for a TimeSafari user
*
* @param timesafariDid TimeSafari DID
* @return CompletableFuture with delivery analytics
*/
public CompletableFuture<DeliveryAnalytics> getDeliveryAnalytics(String timesafariDid) {
return CompletableFuture.supplyAsync(() -> {
try {
List<NotificationDeliveryEntity> deliveries = deliveryDao.getDeliveriesByTimeSafariDid(timesafariDid);
int totalDeliveries = deliveries.size();
int successfulDeliveries = 0;
int failedDeliveries = 0;
long totalDuration = 0;
int userInteractions = 0;
for (NotificationDeliveryEntity delivery : deliveries) {
if (delivery.isSuccessful()) {
successfulDeliveries++;
totalDuration += delivery.deliveryDurationMs;
} else {
failedDeliveries++;
}
if (delivery.hasUserInteraction()) {
userInteractions++;
}
}
double successRate = totalDeliveries > 0 ? (double) successfulDeliveries / totalDeliveries : 0.0;
double averageDuration = successfulDeliveries > 0 ? (double) totalDuration / successfulDeliveries : 0.0;
double interactionRate = totalDeliveries > 0 ? (double) userInteractions / totalDeliveries : 0.0;
return new DeliveryAnalytics(
totalDeliveries,
successfulDeliveries,
failedDeliveries,
successRate,
averageDuration,
userInteractions,
interactionRate
);
} catch (Exception e) {
Log.e(TAG, "Failed to get delivery analytics for DID: " + timesafariDid, e);
return null;
}
}, executorService);
}
// ===== CONFIGURATION OPERATIONS =====
/**
* Save configuration value
*
* @param timesafariDid TimeSafari DID (null for global settings)
* @param configType Configuration type
* @param configKey Configuration key
* @param configValue Configuration value
* @return CompletableFuture with success status
*/
public CompletableFuture<Boolean> saveConfiguration(String timesafariDid, String configType,
String configKey, Object configValue) {
return CompletableFuture.supplyAsync(() -> {
try {
String id = timesafariDid != null ? timesafariDid + "_" + configKey : configKey;
NotificationConfigEntity config = new NotificationConfigEntity(
id, timesafariDid, configType, configKey, null, null
);
config.setTypedValue(configValue);
config.touch();
configDao.insertConfig(config);
Log.d(TAG, "Saved configuration: " + configKey + " = " + configValue);
return true;
} catch (Exception e) {
Log.e(TAG, "Failed to save configuration: " + configKey, e);
return false;
}
}, executorService);
}
/**
* Get configuration value
*
* @param timesafariDid TimeSafari DID (null for global settings)
* @param configKey Configuration key
* @return CompletableFuture with configuration value
*/
public CompletableFuture<Object> getConfiguration(String timesafariDid, String configKey) {
return CompletableFuture.supplyAsync(() -> {
try {
NotificationConfigEntity config = configDao.getConfigByKeyAndDid(configKey, timesafariDid);
if (config != null && config.isActive && !config.isExpired()) {
return config.getParsedValue();
}
return null;
} catch (Exception e) {
Log.e(TAG, "Failed to get configuration: " + configKey, e);
return null;
}
}, executorService);
}
/**
* Get user preferences
*
* @param timesafariDid TimeSafari DID
* @return CompletableFuture with user preferences
*/
public CompletableFuture<List<NotificationConfigEntity>> getUserPreferences(String timesafariDid) {
return CompletableFuture.supplyAsync(() -> {
try {
return configDao.getUserPreferences(timesafariDid);
} catch (Exception e) {
Log.e(TAG, "Failed to get user preferences for DID: " + timesafariDid, e);
return null;
}
}, executorService);
}
// ===== CLEANUP OPERATIONS =====
/**
* Clean up expired data
*
* @return CompletableFuture with cleanup results
*/
public CompletableFuture<CleanupResults> cleanupExpiredData() {
return CompletableFuture.supplyAsync(() -> {
try {
long currentTime = System.currentTimeMillis();
int deletedNotifications = contentDao.deleteExpiredNotifications(currentTime);
int deletedDeliveries = deliveryDao.deleteOldDeliveries(currentTime - (30L * 24 * 60 * 60 * 1000));
int deletedConfigs = configDao.deleteExpiredConfigs(currentTime);
Log.d(TAG, "Cleanup completed: " + deletedNotifications + " notifications, " +
deletedDeliveries + " deliveries, " + deletedConfigs + " configs");
return new CleanupResults(deletedNotifications, deletedDeliveries, deletedConfigs);
} catch (Exception e) {
Log.e(TAG, "Failed to cleanup expired data", e);
return new CleanupResults(0, 0, 0);
}
}, executorService);
}
/**
* Clear all data for a TimeSafari user
*
* @param timesafariDid TimeSafari DID
* @return CompletableFuture with success status
*/
public CompletableFuture<Boolean> clearUserData(String timesafariDid) {
return CompletableFuture.supplyAsync(() -> {
try {
int deletedNotifications = contentDao.deleteNotificationsByTimeSafariDid(timesafariDid);
int deletedDeliveries = deliveryDao.deleteDeliveriesByTimeSafariDid(timesafariDid);
int deletedConfigs = configDao.deleteConfigsByTimeSafariDid(timesafariDid);
Log.d(TAG, "Cleared user data for DID: " + timesafariDid +
" (" + deletedNotifications + " notifications, " +
deletedDeliveries + " deliveries, " + deletedConfigs + " configs)");
return true;
} catch (Exception e) {
Log.e(TAG, "Failed to clear user data for DID: " + timesafariDid, e);
return false;
}
}, executorService);
}
// ===== ANALYTICS OPERATIONS =====
/**
* Get comprehensive plugin analytics
*
* @return CompletableFuture with plugin analytics
*/
public CompletableFuture<PluginAnalytics> getPluginAnalytics() {
return CompletableFuture.supplyAsync(() -> {
try {
int totalNotifications = contentDao.getTotalNotificationCount();
int totalDeliveries = deliveryDao.getTotalDeliveryCount();
int totalConfigs = configDao.getTotalConfigCount();
int successfulDeliveries = deliveryDao.getSuccessfulDeliveryCount();
int failedDeliveries = deliveryDao.getFailedDeliveryCount();
int userInteractions = deliveryDao.getUserInteractionCount();
double successRate = totalDeliveries > 0 ? (double) successfulDeliveries / totalDeliveries : 0.0;
double interactionRate = totalDeliveries > 0 ? (double) userInteractions / totalDeliveries : 0.0;
return new PluginAnalytics(
totalNotifications,
totalDeliveries,
totalConfigs,
successfulDeliveries,
failedDeliveries,
successRate,
userInteractions,
interactionRate
);
} catch (Exception e) {
Log.e(TAG, "Failed to get plugin analytics", e);
return null;
}
}, executorService);
}
// ===== DATA CLASSES =====
/**
* Delivery analytics data class
*/
public static class DeliveryAnalytics {
public final int totalDeliveries;
public final int successfulDeliveries;
public final int failedDeliveries;
public final double successRate;
public final double averageDuration;
public final int userInteractions;
public final double interactionRate;
public DeliveryAnalytics(int totalDeliveries, int successfulDeliveries, int failedDeliveries,
double successRate, double averageDuration, int userInteractions, double interactionRate) {
this.totalDeliveries = totalDeliveries;
this.successfulDeliveries = successfulDeliveries;
this.failedDeliveries = failedDeliveries;
this.successRate = successRate;
this.averageDuration = averageDuration;
this.userInteractions = userInteractions;
this.interactionRate = interactionRate;
}
@Override
public String toString() {
return String.format("DeliveryAnalytics{total=%d, successful=%d, failed=%d, successRate=%.2f%%, avgDuration=%.2fms, interactions=%d, interactionRate=%.2f%%}",
totalDeliveries, successfulDeliveries, failedDeliveries, successRate * 100, averageDuration, userInteractions, interactionRate * 100);
}
}
/**
* Cleanup results data class
*/
public static class CleanupResults {
public final int deletedNotifications;
public final int deletedDeliveries;
public final int deletedConfigs;
public CleanupResults(int deletedNotifications, int deletedDeliveries, int deletedConfigs) {
this.deletedNotifications = deletedNotifications;
this.deletedDeliveries = deletedDeliveries;
this.deletedConfigs = deletedConfigs;
}
@Override
public String toString() {
return String.format("CleanupResults{notifications=%d, deliveries=%d, configs=%d}",
deletedNotifications, deletedDeliveries, deletedConfigs);
}
}
/**
* Plugin analytics data class
*/
public static class PluginAnalytics {
public final int totalNotifications;
public final int totalDeliveries;
public final int totalConfigs;
public final int successfulDeliveries;
public final int failedDeliveries;
public final double successRate;
public final int userInteractions;
public final double interactionRate;
public PluginAnalytics(int totalNotifications, int totalDeliveries, int totalConfigs,
int successfulDeliveries, int failedDeliveries, double successRate,
int userInteractions, double interactionRate) {
this.totalNotifications = totalNotifications;
this.totalDeliveries = totalDeliveries;
this.totalConfigs = totalConfigs;
this.successfulDeliveries = successfulDeliveries;
this.failedDeliveries = failedDeliveries;
this.successRate = successRate;
this.userInteractions = userInteractions;
this.interactionRate = interactionRate;
}
@Override
public String toString() {
return String.format("PluginAnalytics{notifications=%d, deliveries=%d, configs=%d, successRate=%.2f%%, interactions=%d, interactionRate=%.2f%%}",
totalNotifications, totalDeliveries, totalConfigs, successRate * 100, userInteractions, interactionRate * 100);
}
}
/**
* Close the storage and cleanup resources
*/
public void close() {
executorService.shutdown();
Log.d(TAG, "Room-based storage closed");
}
}