Integrate Daily Notification Plugin #214
Open
anomalist
wants to merge 21 commits from integrate-notification-plugin into master
21 changed files with 3856 additions and 1 deletions
@ -0,0 +1,118 @@ |
|||
/** |
|||
* TimeSafariApplication.java |
|||
* |
|||
* Application class for the TimeSafari app. |
|||
* Registers the native content fetcher for the Daily Notification Plugin. |
|||
* |
|||
* @author TimeSafari Team |
|||
* @version 1.0.0 |
|||
*/ |
|||
|
|||
package app.timesafari; |
|||
|
|||
import android.app.Application; |
|||
import android.app.NotificationChannel; |
|||
import android.app.NotificationManager; |
|||
import android.content.Context; |
|||
import android.os.Build; |
|||
import android.util.Log; |
|||
import com.timesafari.dailynotification.DailyNotificationPlugin; |
|||
import com.timesafari.dailynotification.NativeNotificationContentFetcher; |
|||
|
|||
/** |
|||
* Application class that registers native fetcher for daily notifications |
|||
*/ |
|||
public class TimeSafariApplication extends Application { |
|||
|
|||
private static final String TAG = "TimeSafariApplication"; |
|||
|
|||
@Override |
|||
public void onCreate() { |
|||
super.onCreate(); |
|||
|
|||
// Instrumentation: Log app initialization with process info
|
|||
int pid = android.os.Process.myPid(); |
|||
String processName = getApplicationInfo().processName; |
|||
Log.i(TAG, String.format( |
|||
"APP|ON_CREATE ts=%d pid=%d processName=%s", |
|||
System.currentTimeMillis(), |
|||
pid, |
|||
processName |
|||
)); |
|||
|
|||
Log.i(TAG, "Initializing TimeSafari Application"); |
|||
|
|||
// Create notification channel for daily notifications (required for Android 8.0+)
|
|||
createNotificationChannel(); |
|||
|
|||
// Register native fetcher with application context
|
|||
Context context = getApplicationContext(); |
|||
NativeNotificationContentFetcher nativeFetcher = |
|||
new TimeSafariNativeFetcher(context); |
|||
|
|||
// Instrumentation: Log before registration
|
|||
Log.i(TAG, String.format( |
|||
"FETCHER|REGISTER_START instanceHash=%d ts=%d", |
|||
nativeFetcher.hashCode(), |
|||
System.currentTimeMillis() |
|||
)); |
|||
|
|||
DailyNotificationPlugin.setNativeFetcher(nativeFetcher); |
|||
|
|||
// Instrumentation: Verify registration succeeded
|
|||
NativeNotificationContentFetcher verified = |
|||
DailyNotificationPlugin.getNativeFetcherStatic(); |
|||
boolean registered = (verified != null && verified == nativeFetcher); |
|||
|
|||
Log.i(TAG, String.format( |
|||
"FETCHER|REGISTERED providerKey=DailyNotificationPlugin instanceHash=%d registered=%s ts=%d", |
|||
nativeFetcher.hashCode(), |
|||
registered, |
|||
System.currentTimeMillis() |
|||
)); |
|||
|
|||
Log.i(TAG, "Native fetcher registered: " + nativeFetcher.getClass().getName()); |
|||
} |
|||
|
|||
/** |
|||
* Create notification channel for daily notifications |
|||
* Required for Android 8.0 (API 26) and above |
|||
*/ |
|||
private void createNotificationChannel() { |
|||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { |
|||
NotificationManager notificationManager = |
|||
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE); |
|||
|
|||
if (notificationManager == null) { |
|||
Log.w(TAG, "NotificationManager is null, cannot create channel"); |
|||
return; |
|||
} |
|||
|
|||
// Channel ID must match the one used in DailyNotificationWorker
|
|||
String channelId = "timesafari.daily"; |
|||
String channelName = "Daily Notifications"; |
|||
String channelDescription = "Daily notification updates from TimeSafari"; |
|||
|
|||
// Check if channel already exists
|
|||
NotificationChannel existingChannel = notificationManager.getNotificationChannel(channelId); |
|||
if (existingChannel != null) { |
|||
Log.d(TAG, "Notification channel already exists: " + channelId); |
|||
return; |
|||
} |
|||
|
|||
// Create the channel with high importance (for priority="high" notifications)
|
|||
NotificationChannel channel = new NotificationChannel( |
|||
channelId, |
|||
channelName, |
|||
NotificationManager.IMPORTANCE_HIGH |
|||
); |
|||
channel.setDescription(channelDescription); |
|||
channel.enableVibration(true); |
|||
channel.setShowBadge(true); |
|||
|
|||
notificationManager.createNotificationChannel(channel); |
|||
Log.i(TAG, "Notification channel created: " + channelId); |
|||
} |
|||
} |
|||
} |
|||
|
|||
@ -0,0 +1,605 @@ |
|||
/** |
|||
* TimeSafariNativeFetcher.java |
|||
* |
|||
* Implementation of NativeNotificationContentFetcher for the TimeSafari app. |
|||
* Fetches notification content from the endorser API endpoint. |
|||
* |
|||
* @author TimeSafari Team |
|||
* @version 1.0.0 |
|||
*/ |
|||
|
|||
package app.timesafari; |
|||
|
|||
import android.content.Context; |
|||
import android.content.SharedPreferences; |
|||
import android.util.Log; |
|||
import androidx.annotation.NonNull; |
|||
import com.timesafari.dailynotification.FetchContext; |
|||
import com.timesafari.dailynotification.NativeNotificationContentFetcher; |
|||
import com.timesafari.dailynotification.NotificationContent; |
|||
import com.google.gson.Gson; |
|||
import com.google.gson.JsonObject; |
|||
import com.google.gson.JsonArray; |
|||
import com.google.gson.JsonParser; |
|||
import java.io.BufferedReader; |
|||
import java.io.InputStreamReader; |
|||
import java.io.OutputStream; |
|||
import java.net.HttpURLConnection; |
|||
import java.net.URL; |
|||
import java.nio.charset.StandardCharsets; |
|||
import java.util.ArrayList; |
|||
import java.util.Collections; |
|||
import java.util.HashMap; |
|||
import java.util.List; |
|||
import java.util.Map; |
|||
import java.util.concurrent.CompletableFuture; |
|||
|
|||
/** |
|||
* Native content fetcher implementation for TimeSafari |
|||
* |
|||
* Fetches notification content from the endorser API endpoint. |
|||
* Uses the same endpoint as the TypeScript code: /api/v2/report/plansLastUpdatedBetween |
|||
*/ |
|||
public class TimeSafariNativeFetcher implements NativeNotificationContentFetcher { |
|||
|
|||
private static final String TAG = "TimeSafariNativeFetcher"; |
|||
private static final String ENDORSER_ENDPOINT = "/api/v2/report/plansLastUpdatedBetween"; |
|||
private static final int CONNECT_TIMEOUT_MS = 10000; // 10 seconds
|
|||
private static final int READ_TIMEOUT_MS = 15000; // 15 seconds
|
|||
private static final int MAX_RETRIES = 3; // Maximum number of retry attempts
|
|||
private static final int RETRY_DELAY_MS = 1000; // Base delay for exponential backoff
|
|||
|
|||
// SharedPreferences constants
|
|||
// NOTE: Must match plugin's SharedPreferences name and keys for starred plans
|
|||
// Plugin uses "daily_notification_timesafari" (see DailyNotificationPlugin.updateStarredPlans)
|
|||
private static final String PREFS_NAME = "daily_notification_timesafari"; |
|||
private static final String KEY_STARRED_PLAN_IDS = "starredPlanIds"; // Matches plugin key
|
|||
private static final String KEY_LAST_ACKED_JWT_ID = "last_acked_jwt_id"; // For pagination
|
|||
|
|||
private final Gson gson = new Gson(); |
|||
private final Context appContext; |
|||
private SharedPreferences prefs; |
|||
|
|||
// Volatile fields for configuration, set via configure() method
|
|||
private volatile String apiBaseUrl; |
|||
private volatile String activeDid; |
|||
private volatile String jwtToken; // Pre-generated JWT token from TypeScript (ES256K signed)
|
|||
|
|||
/** |
|||
* Constructor |
|||
* |
|||
* @param context Application context for SharedPreferences access |
|||
*/ |
|||
public TimeSafariNativeFetcher(Context context) { |
|||
this.appContext = context.getApplicationContext(); |
|||
this.prefs = appContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); |
|||
Log.d(TAG, "TimeSafariNativeFetcher: Initialized with context"); |
|||
} |
|||
|
|||
/** |
|||
* Configure the native fetcher with API credentials |
|||
* |
|||
* Called by the plugin when configureNativeFetcher() is invoked from TypeScript. |
|||
* This method stores the configuration for use in background fetches. |
|||
* |
|||
* <p><b>Architecture Note:</b> The JWT token is pre-generated in TypeScript using |
|||
* TimeSafari's {@code accessTokenForBackground()} function (ES256K DID-based signing). |
|||
* The native fetcher just uses the token directly - no JWT generation needed.</p> |
|||
* |
|||
* @param apiBaseUrl Base URL for API server (e.g., "https://api.endorser.ch") |
|||
* @param activeDid Active DID for authentication (e.g., "did:ethr:0x...") |
|||
* @param jwtToken Pre-generated JWT token (ES256K signed) from TypeScript |
|||
*/ |
|||
@Override |
|||
public void configure(String apiBaseUrl, String activeDid, String jwtToken) { |
|||
// Instrumentation: Log configuration start
|
|||
int pid = android.os.Process.myPid(); |
|||
Log.i(TAG, String.format( |
|||
"FETCHER|CONFIGURE_START instanceHash=%d pid=%d ts=%d", |
|||
this.hashCode(), |
|||
pid, |
|||
System.currentTimeMillis() |
|||
)); |
|||
|
|||
this.apiBaseUrl = apiBaseUrl; |
|||
this.activeDid = activeDid; |
|||
this.jwtToken = jwtToken; |
|||
|
|||
// Instrumentation: Log configuration completion
|
|||
boolean configured = (apiBaseUrl != null && activeDid != null && jwtToken != null); |
|||
Log.i(TAG, String.format( |
|||
"FETCHER|CONFIGURE_COMPLETE instanceHash=%d configured=%s apiBaseUrl=%s activeDid=%s jwtLength=%d ts=%d", |
|||
this.hashCode(), |
|||
configured, |
|||
apiBaseUrl != null ? apiBaseUrl : "null", |
|||
activeDid != null ? activeDid.substring(0, Math.min(30, activeDid.length())) + "..." : "null", |
|||
jwtToken != null ? jwtToken.length() : 0, |
|||
System.currentTimeMillis() |
|||
)); |
|||
|
|||
// Enhanced logging for JWT diagnostic purposes
|
|||
Log.i(TAG, "TimeSafariNativeFetcher: Configured with API: " + apiBaseUrl); |
|||
if (activeDid != null) { |
|||
Log.i(TAG, "TimeSafariNativeFetcher: ActiveDID: " + activeDid.substring(0, Math.min(30, activeDid.length())) + |
|||
(activeDid.length() > 30 ? "..." : "")); |
|||
} else { |
|||
Log.w(TAG, "TimeSafariNativeFetcher: ActiveDID is NULL"); |
|||
} |
|||
|
|||
if (jwtToken != null) { |
|||
Log.i(TAG, "TimeSafariNativeFetcher: JWT token received - Length: " + jwtToken.length() + " chars"); |
|||
// Log first and last 10 chars for verification (not full token for security)
|
|||
String tokenPreview = jwtToken.length() > 20 |
|||
? jwtToken.substring(0, 10) + "..." + jwtToken.substring(jwtToken.length() - 10) |
|||
: jwtToken.substring(0, Math.min(jwtToken.length(), 20)) + "..."; |
|||
Log.d(TAG, "TimeSafariNativeFetcher: JWT preview: " + tokenPreview); |
|||
} else { |
|||
Log.e(TAG, "TimeSafariNativeFetcher: JWT token is NULL - API calls will fail"); |
|||
} |
|||
} |
|||
|
|||
@Override |
|||
@NonNull |
|||
public CompletableFuture<List<NotificationContent>> fetchContent( |
|||
@NonNull FetchContext context) { |
|||
|
|||
// Instrumentation: Log fetch start with context
|
|||
int pid = android.os.Process.myPid(); |
|||
Log.i(TAG, String.format( |
|||
"PREFETCH|START id=%s notifyAt=%d trigger=%s instanceHash=%d pid=%d ts=%d", |
|||
context.scheduledTime != null ? "daily_" + context.scheduledTime : "unknown", |
|||
context.scheduledTime != null ? context.scheduledTime : 0, |
|||
context.trigger, |
|||
this.hashCode(), |
|||
pid, |
|||
System.currentTimeMillis() |
|||
)); |
|||
|
|||
Log.d(TAG, "TimeSafariNativeFetcher: Fetch triggered - trigger=" + context.trigger + |
|||
", scheduledTime=" + context.scheduledTime + ", fetchTime=" + context.fetchTime); |
|||
|
|||
// Start with retry count 0
|
|||
return fetchContentWithRetry(context, 0); |
|||
} |
|||
|
|||
/** |
|||
* Fetch content with retry logic for transient errors |
|||
* |
|||
* @param context Fetch context |
|||
* @param retryCount Current retry attempt (0 for first attempt) |
|||
* @return Future with notification contents or empty list on failure |
|||
*/ |
|||
private CompletableFuture<List<NotificationContent>> fetchContentWithRetry( |
|||
@NonNull FetchContext context, int retryCount) { |
|||
|
|||
return CompletableFuture.supplyAsync(() -> { |
|||
try { |
|||
// Check if configured
|
|||
if (apiBaseUrl == null || activeDid == null || jwtToken == null) { |
|||
Log.e(TAG, String.format( |
|||
"PREFETCH|SOURCE from=fallback reason=not_configured apiBaseUrl=%s activeDid=%s jwtToken=%s ts=%d", |
|||
apiBaseUrl != null ? "set" : "null", |
|||
activeDid != null ? "set" : "null", |
|||
jwtToken != null ? "set" : "null", |
|||
System.currentTimeMillis() |
|||
)); |
|||
Log.e(TAG, "TimeSafariNativeFetcher: Not configured. Call configureNativeFetcher() from TypeScript first."); |
|||
return Collections.emptyList(); |
|||
} |
|||
|
|||
// Instrumentation: Log native fetcher usage
|
|||
Log.i(TAG, String.format( |
|||
"PREFETCH|SOURCE from=native instanceHash=%d apiBaseUrl=%s ts=%d", |
|||
this.hashCode(), |
|||
apiBaseUrl, |
|||
System.currentTimeMillis() |
|||
)); |
|||
|
|||
Log.i(TAG, "TimeSafariNativeFetcher: Starting fetch from " + apiBaseUrl + ENDORSER_ENDPOINT); |
|||
|
|||
// Build request URL
|
|||
String urlString = apiBaseUrl + ENDORSER_ENDPOINT; |
|||
URL url = new URL(urlString); |
|||
|
|||
// Create HTTP connection
|
|||
HttpURLConnection connection = (HttpURLConnection) url.openConnection(); |
|||
connection.setConnectTimeout(CONNECT_TIMEOUT_MS); |
|||
connection.setReadTimeout(READ_TIMEOUT_MS); |
|||
connection.setRequestMethod("POST"); |
|||
connection.setRequestProperty("Content-Type", "application/json"); |
|||
|
|||
// Diagnostic logging for JWT usage
|
|||
if (jwtToken != null) { |
|||
String jwtPreview = jwtToken.length() > 20 |
|||
? jwtToken.substring(0, 10) + "..." + jwtToken.substring(jwtToken.length() - 10) |
|||
: jwtToken; |
|||
Log.d(TAG, "TimeSafariNativeFetcher: Using JWT for API call - Length: " + jwtToken.length() + |
|||
", Preview: " + jwtPreview + ", ActiveDID: " + |
|||
(activeDid != null ? activeDid.substring(0, Math.min(30, activeDid.length())) + "..." : "null")); |
|||
} else { |
|||
Log.e(TAG, "TimeSafariNativeFetcher: JWT token is NULL when making API call!"); |
|||
} |
|||
|
|||
connection.setRequestProperty("Authorization", "Bearer " + jwtToken); |
|||
connection.setDoOutput(true); |
|||
|
|||
// Build request body
|
|||
Map<String, Object> requestBody = new HashMap<>(); |
|||
requestBody.put("planIds", getStarredPlanIds()); |
|||
|
|||
// afterId is required by the API endpoint
|
|||
// Use "0" for first request (no previous data), or stored jwtId for subsequent requests
|
|||
String afterId = getLastAcknowledgedJwtId(); |
|||
if (afterId == null || afterId.isEmpty()) { |
|||
afterId = "0"; // First request - start from beginning
|
|||
} |
|||
requestBody.put("afterId", afterId); |
|||
|
|||
String jsonBody = gson.toJson(requestBody); |
|||
Log.d(TAG, "TimeSafariNativeFetcher: Request body: " + jsonBody); |
|||
|
|||
// Write request body
|
|||
try (OutputStream os = connection.getOutputStream()) { |
|||
byte[] input = jsonBody.getBytes(StandardCharsets.UTF_8); |
|||
os.write(input, 0, input.length); |
|||
} |
|||
|
|||
// Execute request
|
|||
int responseCode = connection.getResponseCode(); |
|||
Log.d(TAG, "TimeSafariNativeFetcher: HTTP response code: " + responseCode); |
|||
|
|||
if (responseCode == 200) { |
|||
// Read response
|
|||
BufferedReader reader = new BufferedReader( |
|||
new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8)); |
|||
StringBuilder response = new StringBuilder(); |
|||
String line; |
|||
while ((line = reader.readLine()) != null) { |
|||
response.append(line); |
|||
} |
|||
reader.close(); |
|||
|
|||
String responseBody = response.toString(); |
|||
Log.d(TAG, "TimeSafariNativeFetcher: Response body length: " + responseBody.length()); |
|||
|
|||
// Parse response and convert to NotificationContent
|
|||
List<NotificationContent> contents = parseApiResponse(responseBody, context); |
|||
|
|||
// Update last acknowledged JWT ID from the response (for pagination)
|
|||
if (!contents.isEmpty()) { |
|||
// Get the last JWT ID from the parsed response (stored during parsing)
|
|||
updateLastAckedJwtIdFromResponse(contents, responseBody); |
|||
} |
|||
|
|||
Log.i(TAG, "TimeSafariNativeFetcher: Successfully fetched " + contents.size() + |
|||
" notification(s)"); |
|||
|
|||
// Instrumentation: Log successful fetch
|
|||
Log.i(TAG, String.format( |
|||
"PREFETCH|WRITE_OK id=%s items=%d ts=%d", |
|||
context.scheduledTime != null ? "daily_" + context.scheduledTime : "unknown", |
|||
contents.size(), |
|||
System.currentTimeMillis() |
|||
)); |
|||
|
|||
return contents; |
|||
|
|||
} else { |
|||
// Read error response
|
|||
String errorMessage = "Unknown error"; |
|||
try { |
|||
BufferedReader reader = new BufferedReader( |
|||
new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8)); |
|||
StringBuilder errorResponse = new StringBuilder(); |
|||
String line; |
|||
while ((line = reader.readLine()) != null) { |
|||
errorResponse.append(line); |
|||
} |
|||
reader.close(); |
|||
errorMessage = errorResponse.toString(); |
|||
} catch (Exception e) { |
|||
Log.w(TAG, "TimeSafariNativeFetcher: Could not read error stream", e); |
|||
} |
|||
|
|||
Log.e(TAG, "TimeSafariNativeFetcher: API error " + responseCode + ": " + errorMessage); |
|||
|
|||
// Handle retryable errors (5xx server errors, network timeouts)
|
|||
if (shouldRetry(responseCode, retryCount)) { |
|||
long delayMs = RETRY_DELAY_MS * (1 << retryCount); // Exponential backoff
|
|||
Log.w(TAG, "TimeSafariNativeFetcher: Retryable error, retrying in " + delayMs + "ms " + |
|||
"(" + (retryCount + 1) + "/" + MAX_RETRIES + ")"); |
|||
|
|||
try { |
|||
Thread.sleep(delayMs); |
|||
} catch (InterruptedException e) { |
|||
Thread.currentThread().interrupt(); |
|||
Log.e(TAG, "TimeSafariNativeFetcher: Retry delay interrupted", e); |
|||
return Collections.emptyList(); |
|||
} |
|||
|
|||
// Recursive retry
|
|||
return fetchContentWithRetry(context, retryCount + 1).join(); |
|||
} |
|||
|
|||
// Non-retryable errors (4xx client errors, max retries reached)
|
|||
if (responseCode >= 400 && responseCode < 500) { |
|||
Log.e(TAG, "TimeSafariNativeFetcher: Non-retryable client error " + responseCode); |
|||
} else if (retryCount >= MAX_RETRIES) { |
|||
Log.e(TAG, "TimeSafariNativeFetcher: Max retries (" + MAX_RETRIES + ") reached"); |
|||
} |
|||
|
|||
// Return empty list on error (fallback will be handled by worker)
|
|||
return Collections.emptyList(); |
|||
} |
|||
|
|||
} catch (java.net.SocketTimeoutException | java.net.UnknownHostException e) { |
|||
// Network errors are retryable
|
|||
Log.w(TAG, "TimeSafariNativeFetcher: Network error during fetch", e); |
|||
|
|||
if (shouldRetry(0, retryCount)) { // Use 0 as response code for network errors
|
|||
long delayMs = RETRY_DELAY_MS * (1 << retryCount); |
|||
Log.w(TAG, "TimeSafariNativeFetcher: Retrying after network error in " + delayMs + "ms " + |
|||
"(" + (retryCount + 1) + "/" + MAX_RETRIES + ")"); |
|||
|
|||
try { |
|||
Thread.sleep(delayMs); |
|||
} catch (InterruptedException ie) { |
|||
Thread.currentThread().interrupt(); |
|||
Log.e(TAG, "TimeSafariNativeFetcher: Retry delay interrupted", ie); |
|||
return Collections.emptyList(); |
|||
} |
|||
|
|||
return fetchContentWithRetry(context, retryCount + 1).join(); |
|||
} |
|||
|
|||
Log.e(TAG, "TimeSafariNativeFetcher: Max retries reached for network error"); |
|||
return Collections.emptyList(); |
|||
|
|||
} catch (Exception e) { |
|||
Log.e(TAG, "TimeSafariNativeFetcher: Error during fetch", e); |
|||
// Non-retryable errors (parsing, configuration, etc.)
|
|||
return Collections.emptyList(); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Determine if an error should be retried |
|||
* |
|||
* @param responseCode HTTP response code (0 for network errors) |
|||
* @param retryCount Current retry attempt count |
|||
* @return true if error is retryable and retry count not exceeded |
|||
*/ |
|||
private boolean shouldRetry(int responseCode, int retryCount) { |
|||
if (retryCount >= MAX_RETRIES) { |
|||
return false; // Max retries exceeded
|
|||
} |
|||
|
|||
// Retry on network errors (responseCode 0) or server errors (5xx)
|
|||
// Don't retry on client errors (4xx) as they indicate permanent issues
|
|||
if (responseCode == 0) { |
|||
return true; // Network error (timeout, unknown host, etc.)
|
|||
} |
|||
|
|||
if (responseCode >= 500 && responseCode < 600) { |
|||
return true; // Server error (retryable)
|
|||
} |
|||
|
|||
// Some 4xx errors might be retryable (e.g., 429 Too Many Requests)
|
|||
if (responseCode == 429) { |
|||
return true; // Rate limit - retry with backoff
|
|||
} |
|||
|
|||
return false; // Other client errors (401, 403, 404, etc.) are not retryable
|
|||
} |
|||
|
|||
/** |
|||
* Get starred plan IDs from SharedPreferences |
|||
* |
|||
* @return List of starred plan IDs, empty list if none stored |
|||
*/ |
|||
private List<String> getStarredPlanIds() { |
|||
try { |
|||
// Use the same SharedPreferences as the plugin (not the instance variable 'prefs')
|
|||
// Plugin stores in "daily_notification_timesafari" with key "starredPlanIds"
|
|||
SharedPreferences pluginPrefs = appContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE); |
|||
String idsJson = pluginPrefs.getString(KEY_STARRED_PLAN_IDS, "[]"); |
|||
|
|||
if (idsJson == null || idsJson.isEmpty() || idsJson.equals("[]")) { |
|||
Log.d(TAG, "TimeSafariNativeFetcher: No starred plan IDs found in SharedPreferences"); |
|||
return new ArrayList<>(); |
|||
} |
|||
|
|||
// Parse JSON array (plugin stores as JSON string)
|
|||
JsonParser parser = new JsonParser(); |
|||
JsonArray jsonArray = parser.parse(idsJson).getAsJsonArray(); |
|||
List<String> planIds = new ArrayList<>(); |
|||
|
|||
for (int i = 0; i < jsonArray.size(); i++) { |
|||
planIds.add(jsonArray.get(i).getAsString()); |
|||
} |
|||
|
|||
Log.i(TAG, "TimeSafariNativeFetcher: Loaded " + planIds.size() + " starred plan IDs from SharedPreferences"); |
|||
if (planIds.size() > 0) { |
|||
Log.d(TAG, "TimeSafariNativeFetcher: First plan ID: " + |
|||
planIds.get(0).substring(0, Math.min(30, planIds.get(0).length())) + "..."); |
|||
} |
|||
return planIds; |
|||
|
|||
} catch (Exception e) { |
|||
Log.e(TAG, "TimeSafariNativeFetcher: Error loading starred plan IDs from SharedPreferences", e); |
|||
return new ArrayList<>(); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Get last acknowledged JWT ID from SharedPreferences (for pagination) |
|||
* |
|||
* @return Last acknowledged JWT ID, or null if none stored |
|||
*/ |
|||
private String getLastAcknowledgedJwtId() { |
|||
try { |
|||
String jwtId = prefs.getString(KEY_LAST_ACKED_JWT_ID, null); |
|||
if (jwtId != null) { |
|||
Log.d(TAG, "TimeSafariNativeFetcher: Loaded last acknowledged JWT ID"); |
|||
} |
|||
return jwtId; |
|||
} catch (Exception e) { |
|||
Log.e(TAG, "TimeSafariNativeFetcher: Error loading last acknowledged JWT ID", e); |
|||
return null; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Update last acknowledged JWT ID from the API response |
|||
* Uses the last JWT ID from the data array for pagination |
|||
* |
|||
* @param contents Parsed notification contents (may contain JWT IDs) |
|||
* @param responseBody Original response body for parsing |
|||
*/ |
|||
private void updateLastAckedJwtIdFromResponse(List<NotificationContent> contents, String responseBody) { |
|||
try { |
|||
JsonParser parser = new JsonParser(); |
|||
JsonObject root = parser.parse(responseBody).getAsJsonObject(); |
|||
JsonArray dataArray = root.getAsJsonArray("data"); |
|||
|
|||
if (dataArray != null && dataArray.size() > 0) { |
|||
// Get the last item's JWT ID (most recent)
|
|||
JsonObject lastItem = dataArray.get(dataArray.size() - 1).getAsJsonObject(); |
|||
|
|||
// Try to get JWT ID from different possible locations in response structure
|
|||
String jwtId = null; |
|||
if (lastItem.has("jwtId")) { |
|||
jwtId = lastItem.get("jwtId").getAsString(); |
|||
} else if (lastItem.has("plan")) { |
|||
JsonObject plan = lastItem.getAsJsonObject("plan"); |
|||
if (plan.has("jwtId")) { |
|||
jwtId = plan.get("jwtId").getAsString(); |
|||
} |
|||
} |
|||
|
|||
if (jwtId != null && !jwtId.isEmpty()) { |
|||
updateLastAckedJwtId(jwtId); |
|||
Log.d(TAG, "TimeSafariNativeFetcher: Updated last acknowledged JWT ID: " + |
|||
jwtId.substring(0, Math.min(20, jwtId.length())) + "..."); |
|||
} |
|||
} |
|||
} catch (Exception e) { |
|||
Log.w(TAG, "TimeSafariNativeFetcher: Could not extract JWT ID from response for pagination", e); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Update last acknowledged JWT ID in SharedPreferences |
|||
* |
|||
* @param jwtId JWT ID to store as last acknowledged |
|||
*/ |
|||
private void updateLastAckedJwtId(String jwtId) { |
|||
try { |
|||
prefs.edit().putString(KEY_LAST_ACKED_JWT_ID, jwtId).apply(); |
|||
Log.d(TAG, "TimeSafariNativeFetcher: Updated last acknowledged JWT ID"); |
|||
} catch (Exception e) { |
|||
Log.e(TAG, "TimeSafariNativeFetcher: Error updating last acknowledged JWT ID", e); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Parse API response and convert to NotificationContent list |
|||
*/ |
|||
private List<NotificationContent> parseApiResponse(String responseBody, FetchContext context) { |
|||
List<NotificationContent> contents = new ArrayList<>(); |
|||
|
|||
try { |
|||
JsonParser parser = new JsonParser(); |
|||
JsonObject root = parser.parse(responseBody).getAsJsonObject(); |
|||
|
|||
// Parse response structure (matches PlansLastUpdatedResponse)
|
|||
JsonArray dataArray = root.getAsJsonArray("data"); |
|||
if (dataArray != null) { |
|||
for (int i = 0; i < dataArray.size(); i++) { |
|||
JsonObject item = dataArray.get(i).getAsJsonObject(); |
|||
|
|||
NotificationContent content = new NotificationContent(); |
|||
|
|||
// Extract data from API response
|
|||
// Support both flat structure (jwtId, planId) and nested (plan.jwtId, plan.handleId)
|
|||
String planId = null; |
|||
String jwtId = null; |
|||
|
|||
if (item.has("planId")) { |
|||
planId = item.get("planId").getAsString(); |
|||
} else if (item.has("plan")) { |
|||
JsonObject plan = item.getAsJsonObject("plan"); |
|||
if (plan.has("handleId")) { |
|||
planId = plan.get("handleId").getAsString(); |
|||
} |
|||
} |
|||
|
|||
if (item.has("jwtId")) { |
|||
jwtId = item.get("jwtId").getAsString(); |
|||
} else if (item.has("plan")) { |
|||
JsonObject plan = item.getAsJsonObject("plan"); |
|||
if (plan.has("jwtId")) { |
|||
jwtId = plan.get("jwtId").getAsString(); |
|||
} |
|||
} |
|||
|
|||
// Create notification ID
|
|||
String notificationId = "endorser_" + (jwtId != null ? jwtId : |
|||
System.currentTimeMillis() + "_" + i); |
|||
content.setId(notificationId); |
|||
|
|||
// Create notification title
|
|||
String title = "Project Update"; |
|||
if (planId != null) { |
|||
title = "Update: " + planId.substring(Math.max(0, planId.length() - 8)); |
|||
} |
|||
content.setTitle(title); |
|||
|
|||
// Create notification body
|
|||
StringBuilder body = new StringBuilder(); |
|||
if (planId != null) { |
|||
body.append("Plan ").append(planId.substring(Math.max(0, planId.length() - 12))).append(" has been updated."); |
|||
} else { |
|||
body.append("A project you follow has been updated."); |
|||
} |
|||
content.setBody(body.toString()); |
|||
|
|||
// Use scheduled time from context, or default to 1 hour from now
|
|||
long scheduledTimeMs = context.scheduledTime != null ? |
|||
context.scheduledTime : (System.currentTimeMillis() + 3600000); |
|||
content.setScheduledTime(scheduledTimeMs); |
|||
|
|||
// Set notification properties
|
|||
content.setPriority("default"); |
|||
content.setSound(true); |
|||
|
|||
contents.add(content); |
|||
} |
|||
} |
|||
|
|||
// If no data items, create a default notification
|
|||
if (contents.isEmpty()) { |
|||
NotificationContent defaultContent = new NotificationContent(); |
|||
defaultContent.setId("endorser_no_updates_" + System.currentTimeMillis()); |
|||
defaultContent.setTitle("No Project Updates"); |
|||
defaultContent.setBody("No updates found in your starred projects."); |
|||
|
|||
long scheduledTimeMs = context.scheduledTime != null ? |
|||
context.scheduledTime : (System.currentTimeMillis() + 3600000); |
|||
defaultContent.setScheduledTime(scheduledTimeMs); |
|||
defaultContent.setPriority("default"); |
|||
defaultContent.setSound(true); |
|||
|
|||
contents.add(defaultContent); |
|||
} |
|||
|
|||
} catch (Exception e) { |
|||
Log.e(TAG, "TimeSafariNativeFetcher: Error parsing API response", e); |
|||
// Return empty list on parse error
|
|||
} |
|||
|
|||
return contents; |
|||
} |
|||
} |
|||
|
|||
File diff suppressed because it is too large
@ -0,0 +1,109 @@ |
|||
# Fix Notification Dismiss to Cancel Notification |
|||
|
|||
## Problem |
|||
|
|||
When a user clicks the "Dismiss" button on a daily notification, the notification is removed from storage and alarms are cancelled, but the notification itself is not cancelled from the NotificationManager. This means the notification remains visible in the system tray even though it's been dismissed. |
|||
|
|||
Additionally, clicking on the notification (not the dismiss button) launches the app, which is working as intended. |
|||
|
|||
## Root Cause |
|||
|
|||
In `DailyNotificationWorker.java`, the `handleDismissNotification()` method: |
|||
1. ✅ Removes notification from storage |
|||
2. ✅ Cancels pending alarms |
|||
3. ❌ **MISSING**: Does not cancel the notification from NotificationManager |
|||
|
|||
The notification is displayed with ID = `content.getId().hashCode()` (line 440), but this ID is never used to cancel the notification when dismissing. |
|||
|
|||
## Solution |
|||
|
|||
Add notification cancellation to `handleDismissNotification()` method in `DailyNotificationWorker.java`. |
|||
|
|||
### IMPORTANT: Plugin Source Change |
|||
|
|||
**This change must be applied to the plugin source repository**, not the host app. The file is located in the `@timesafari/daily-notification-plugin` package. |
|||
|
|||
### File to Modify |
|||
|
|||
**Plugin Source Repository:** |
|||
`android/src/main/java/com/timesafari/dailynotification/DailyNotificationWorker.java` |
|||
|
|||
**Note:** In the host app's `node_modules`, this file is located at: |
|||
`node_modules/@timesafari/daily-notification-plugin/android/src/main/java/com/timesafari/dailynotification/DailyNotificationWorker.java` |
|||
|
|||
However, changes to `node_modules` will be overwritten on the next `npm install`. This fix must be applied to the plugin's source repository. |
|||
|
|||
### Change Required |
|||
|
|||
In the `handleDismissNotification()` method (around line 177-206), add code to cancel the notification from NotificationManager: |
|||
|
|||
```java |
|||
private Result handleDismissNotification(String notificationId) { |
|||
Trace.beginSection("DN:dismiss"); |
|||
try { |
|||
Log.d(TAG, "DN|DISMISS_START id=" + notificationId); |
|||
|
|||
// Cancel the notification from NotificationManager FIRST |
|||
// This ensures the notification disappears immediately when dismissed |
|||
NotificationManager notificationManager = |
|||
(NotificationManager) getApplicationContext().getSystemService(Context.NOTIFICATION_SERVICE); |
|||
if (notificationManager != null) { |
|||
int systemNotificationId = notificationId.hashCode(); |
|||
notificationManager.cancel(systemNotificationId); |
|||
Log.d(TAG, "DN|DISMISS_CANCEL_NOTIF systemId=" + systemNotificationId); |
|||
} |
|||
|
|||
// Remove from Room if present; also remove from legacy storage for compatibility |
|||
try { |
|||
DailyNotificationStorageRoom room = new DailyNotificationStorageRoom(getApplicationContext()); |
|||
// No direct delete DAO exposed via service; legacy removal still applied |
|||
} catch (Exception ignored) { } |
|||
DailyNotificationStorage storage = new DailyNotificationStorage(getApplicationContext()); |
|||
storage.removeNotification(notificationId); |
|||
|
|||
// Cancel any pending alarms |
|||
DailyNotificationScheduler scheduler = new DailyNotificationScheduler( |
|||
getApplicationContext(), |
|||
(android.app.AlarmManager) getApplicationContext().getSystemService(Context.ALARM_SERVICE) |
|||
); |
|||
scheduler.cancelNotification(notificationId); |
|||
|
|||
Log.i(TAG, "DN|DISMISS_OK id=" + notificationId); |
|||
return Result.success(); |
|||
|
|||
} catch (Exception e) { |
|||
Log.e(TAG, "DN|DISMISS_ERR exception id=" + notificationId + " err=" + e.getMessage(), e); |
|||
return Result.retry(); |
|||
} finally { |
|||
Trace.endSection(); |
|||
} |
|||
} |
|||
``` |
|||
|
|||
### Key Points |
|||
|
|||
1. **Notification ID**: Use `notificationId.hashCode()` to match the ID used when displaying (line 440: `int notificationId = content.getId().hashCode()`) |
|||
2. **Order**: Cancel the notification FIRST, before removing from storage, so it disappears immediately |
|||
3. **Null check**: Check that NotificationManager is not null before calling cancel() |
|||
4. **Logging**: Add instrumentation log to track cancellation |
|||
|
|||
### Expected Behavior After Fix |
|||
|
|||
1. User clicks "Dismiss" button → Notification disappears immediately from system tray |
|||
2. User clicks notification body → App launches (unchanged behavior) |
|||
3. User swipes notification away → Notification dismissed (Android handles this automatically with `setAutoCancel(true)`) |
|||
|
|||
## Testing Checklist |
|||
|
|||
- [ ] Click dismiss button → Notification disappears immediately |
|||
- [ ] Click notification body → App launches |
|||
- [ ] Swipe notification away → Notification dismissed |
|||
- [ ] Check logs for `DN|DISMISS_CANCEL_NOTIF` entry |
|||
- [ ] Verify notification is removed from storage after dismiss |
|||
- [ ] Verify alarms are cancelled after dismiss |
|||
|
|||
## Related Code |
|||
|
|||
- Notification display: `DailyNotificationWorker.displayNotification()` line 440 |
|||
- Notification ID generation: `content.getId().hashCode()` |
|||
- Auto-cancel: `builder.setAutoCancel(true)` line 363 (handles swipe-to-dismiss) |
|||
@ -0,0 +1,109 @@ |
|||
# Prefetch Investigation Summary |
|||
|
|||
## Problem Statement |
|||
|
|||
The daily notification prefetch job (T-5 min) is not calling the native fetcher, resulting in: |
|||
- `from: null` in prefetch logs |
|||
- Fallback/mock content being used |
|||
- `DISPLAY_SKIP content_not_found` at notification time |
|||
- Storage empty (`[]`) when display worker runs |
|||
|
|||
## Root Cause Hypothesis |
|||
|
|||
Based on the directive analysis, likely causes (ranked): |
|||
|
|||
1. **Registration Timing**: Prefetch worker runs before `Application.onCreate()` completes |
|||
2. **Discovery Failure**: Worker resolves fetcher to `null` (wrong scope, process mismatch) |
|||
3. **Persistence Bug**: Content written but wiped/deduped before display |
|||
4. **ID Mismatch**: Prefetch writes `notify_...` but display looks for `daily_...` |
|||
|
|||
## Instrumentation Added |
|||
|
|||
### TimeSafariApplication.java |
|||
- `APP|ON_CREATE ts=... pid=... processName=...` - App initialization timing |
|||
- `FETCHER|REGISTER_START instanceHash=... ts=...` - Before registration |
|||
- `FETCHER|REGISTERED providerKey=... instanceHash=... registered=... ts=...` - After registration with verification |
|||
|
|||
### TimeSafariNativeFetcher.java |
|||
- `FETCHER|CONFIGURE_START instanceHash=... pid=... ts=...` - Configuration start |
|||
- `FETCHER|CONFIGURE_COMPLETE instanceHash=... configured=... apiBaseUrl=... activeDid=... jwtLength=... ts=...` - Configuration completion |
|||
- `PREFETCH|START id=... notifyAt=... trigger=... instanceHash=... pid=... ts=...` - Fetch start |
|||
- `PREFETCH|SOURCE from=native/fallback reason=... ts=...` - Source resolution |
|||
- `PREFETCH|WRITE_OK id=... items=... ts=...` - Successful fetch |
|||
|
|||
## Diagnostic Tools |
|||
|
|||
### Log Filtering Script |
|||
```bash |
|||
./scripts/diagnose-prefetch.sh app.timesafari.app |
|||
``` |
|||
|
|||
Filters logcat for: |
|||
- `APP|ON_CREATE` |
|||
- `FETCHER|*` |
|||
- `PREFETCH|*` |
|||
- `DISPLAY|*` |
|||
- `STORAGE|*` |
|||
|
|||
### Manual Filtering |
|||
```bash |
|||
adb logcat | grep -E "APP\|ON_CREATE|FETCHER\||PREFETCH\||DISPLAY\||STORAGE\|" |
|||
``` |
|||
|
|||
## Investigation Checklist |
|||
|
|||
### A. App/Plugin Initialization Order |
|||
- [ ] Confirm `APP|ON_CREATE` appears before `PREFETCH|START` |
|||
- [ ] Verify `FETCHER|REGISTERED registered=true` |
|||
- [ ] Check for multiple `onCreate` invocations (process restarts) |
|||
- [ ] Confirm single process (no `android:process` on workers) |
|||
|
|||
### B. Prefetch Worker Resolution |
|||
- [ ] Check `PREFETCH|SOURCE from=native` (not `from=fallback`) |
|||
- [ ] Verify `instanceHash` matches between registration and fetch |
|||
- [ ] Compare `pid` values (should be same process) |
|||
- [ ] Check `FETCHER|CONFIGURE_COMPLETE configured=true` before prefetch |
|||
|
|||
### C. Storage & Persistence |
|||
- [ ] Verify `PREFETCH|WRITE_OK items>=1` |
|||
- [ ] Check storage logs for content persistence |
|||
- [ ] Compare prefetch ID vs display lookup ID (must match) |
|||
|
|||
### D. ID Schema Consistency |
|||
- [ ] Prefetch ID format: `daily_<epoch>` or `notify_<epoch>` |
|||
- [ ] Display lookup ID format: must match prefetch ID |
|||
- [ ] Verify ID derivation rules are consistent |
|||
|
|||
## Next Steps |
|||
|
|||
1. **Run diagnostic script** during a notification cycle |
|||
2. **Analyze logs** for timing issues and process mismatches |
|||
3. **If fetcher is null**: Implement Fix #2 (Pass Fetcher Context With Work) or Fix #3 (Process-Safe DI) |
|||
4. **If ID mismatch**: Normalize ID schema across prefetch and display |
|||
5. **If storage issue**: Add transactional writes and read-after-write verification |
|||
|
|||
## Expected Log Flow (Success Case) |
|||
|
|||
``` |
|||
APP|ON_CREATE ts=... pid=... processName=app.timesafari.app |
|||
FETCHER|REGISTER_START instanceHash=... ts=... |
|||
FETCHER|REGISTERED providerKey=DailyNotificationPlugin instanceHash=... registered=true ts=... |
|||
FETCHER|CONFIGURE_START instanceHash=... pid=... ts=... |
|||
FETCHER|CONFIGURE_COMPLETE instanceHash=... configured=true ... ts=... |
|||
PREFETCH|START id=daily_... notifyAt=... trigger=prefetch instanceHash=... pid=... ts=... |
|||
PREFETCH|SOURCE from=native instanceHash=... apiBaseUrl=... ts=... |
|||
PREFETCH|WRITE_OK id=daily_... items=1 ts=... |
|||
STORAGE|POST_PREFETCH total=1 ids=[daily_...] |
|||
DISPLAY|START id=daily_... |
|||
STORAGE|PRE_DISPLAY total=1 ids=[daily_...] |
|||
DISPLAY|LOOKUP result=hit id=daily_... |
|||
``` |
|||
|
|||
## Failure Indicators |
|||
|
|||
- `PREFETCH|SOURCE from=fallback` - Native fetcher not resolved |
|||
- `PREFETCH|SOURCE from=null` - Fetcher registration failed |
|||
- `FETCHER|REGISTERED registered=false` - Registration verification failed |
|||
- `STORAGE|PRE_DISPLAY total=0` - Content not persisted |
|||
- `DISPLAY|LOOKUP result=miss` - ID mismatch or content cleared |
|||
|
|||
@ -0,0 +1,36 @@ |
|||
#!/bin/bash |
|||
# |
|||
# Diagnostic script for daily notification prefetch issues |
|||
# Filters logcat output for prefetch-related instrumentation logs |
|||
# |
|||
# Usage: |
|||
# ./scripts/diagnose-prefetch.sh [package_name] |
|||
# |
|||
# Example: |
|||
# ./scripts/diagnose-prefetch.sh app.timesafari.app |
|||
# |
|||
|
|||
set -e |
|||
|
|||
PACKAGE_NAME="${1:-app.timesafari.app}" |
|||
|
|||
echo "🔍 Daily Notification Prefetch Diagnostic Tool" |
|||
echo "==============================================" |
|||
echo "" |
|||
echo "Package: $PACKAGE_NAME" |
|||
echo "Filtering for instrumentation tags:" |
|||
echo " - APP|ON_CREATE" |
|||
echo " - FETCHER|*" |
|||
echo " - PREFETCH|*" |
|||
echo " - DISPLAY|*" |
|||
echo " - STORAGE|*" |
|||
echo "" |
|||
echo "Press Ctrl+C to stop" |
|||
echo "" |
|||
|
|||
# Filter logcat for instrumentation tags |
|||
adb logcat -c # Clear logcat buffer first |
|||
|
|||
adb logcat | grep -E "APP\|ON_CREATE|FETCHER\||PREFETCH\||DISPLAY\||STORAGE\||DailyNotification|TimeSafariApplication|TimeSafariNativeFetcher" | \ |
|||
grep -i "$PACKAGE_NAME\|TimeSafari\|DailyNotification" |
|||
|
|||
@ -0,0 +1,781 @@ |
|||
<template> |
|||
<section |
|||
v-if="notificationsSupported" |
|||
id="sectionDailyNotifications" |
|||
class="bg-slate-100 rounded-md overflow-hidden px-4 py-4 mt-8 mb-8" |
|||
aria-labelledby="dailyNotificationsHeading" |
|||
> |
|||
<h2 id="dailyNotificationsHeading" class="mb-2 font-bold"> |
|||
Daily Notifications |
|||
<button |
|||
class="text-slate-400 fa-fw cursor-pointer" |
|||
aria-label="Learn more about native notifications" |
|||
@click.stop="showNativeNotificationInfo" |
|||
> |
|||
<font-awesome icon="circle-question" aria-hidden="true" /> |
|||
</button> |
|||
</h2> |
|||
|
|||
<div class="flex items-center justify-between"> |
|||
<div>Daily Notification</div> |
|||
<!-- Toggle switch --> |
|||
<div |
|||
class="relative ml-2 cursor-pointer" |
|||
role="switch" |
|||
:aria-checked="nativeNotificationEnabled" |
|||
:aria-label=" |
|||
nativeNotificationEnabled |
|||
? 'Disable daily notifications' |
|||
: 'Enable daily notifications' |
|||
" |
|||
tabindex="0" |
|||
@click="toggleNativeNotification" |
|||
> |
|||
<!-- input --> |
|||
<input |
|||
:checked="nativeNotificationEnabled" |
|||
type="checkbox" |
|||
class="sr-only" |
|||
tabindex="-1" |
|||
readonly |
|||
/> |
|||
<!-- line --> |
|||
<div |
|||
class="block bg-slate-500 w-14 h-8 rounded-full transition" |
|||
:class="{ |
|||
'bg-blue-600': nativeNotificationEnabled, |
|||
}" |
|||
></div> |
|||
<!-- dot --> |
|||
<div |
|||
class="dot absolute left-1 top-1 bg-slate-400 w-6 h-6 rounded-full transition" |
|||
:class="{ |
|||
'left-7 bg-white': nativeNotificationEnabled, |
|||
}" |
|||
></div> |
|||
</div> |
|||
</div> |
|||
|
|||
<!-- Show "Open Settings" button when permissions are denied --> |
|||
<div |
|||
v-if=" |
|||
notificationsSupported && |
|||
notificationStatus && |
|||
notificationStatus.permissions.notifications === 'denied' |
|||
" |
|||
class="mt-2" |
|||
> |
|||
<button |
|||
class="w-full px-3 py-2 bg-blue-600 text-white rounded text-sm font-medium" |
|||
@click="openNotificationSettings" |
|||
> |
|||
Open Settings |
|||
</button> |
|||
<p class="text-xs text-slate-500 mt-1 text-center"> |
|||
Enable notifications in Settings > App info > Notifications |
|||
</p> |
|||
</div> |
|||
|
|||
<!-- Time input section - show when enabled OR when no time is set --> |
|||
<div |
|||
v-if="nativeNotificationEnabled || !nativeNotificationTimeStorage" |
|||
class="mt-2" |
|||
> |
|||
<div |
|||
v-if="nativeNotificationEnabled" |
|||
class="flex items-center justify-between mb-2" |
|||
> |
|||
<span |
|||
>Scheduled for: |
|||
<span v-if="nativeNotificationTime">{{ |
|||
nativeNotificationTime |
|||
}}</span> |
|||
<span v-else class="text-slate-500">Not set</span></span |
|||
> |
|||
<button |
|||
class="text-blue-500 text-sm" |
|||
@click="editNativeNotificationTime" |
|||
> |
|||
{{ showTimeEdit ? "Cancel" : "Edit Time" }} |
|||
</button> |
|||
</div> |
|||
|
|||
<!-- Time input (shown when editing or when no time is set) --> |
|||
<div v-if="showTimeEdit || !nativeNotificationTimeStorage" class="mt-2"> |
|||
<label class="block text-sm text-slate-600 mb-1"> |
|||
Notification Time |
|||
</label> |
|||
<div class="flex items-center gap-2"> |
|||
<input |
|||
v-model="nativeNotificationTimeStorage" |
|||
type="time" |
|||
class="rounded border border-slate-400 px-2 py-2" |
|||
@change="onTimeChange" |
|||
/> |
|||
<button |
|||
v-if="showTimeEdit || nativeNotificationTimeStorage" |
|||
class="px-3 py-2 bg-blue-600 text-white rounded" |
|||
@click="saveTimeChange" |
|||
> |
|||
Save |
|||
</button> |
|||
</div> |
|||
<p |
|||
v-if="!nativeNotificationTimeStorage" |
|||
class="text-xs text-slate-500 mt-1" |
|||
> |
|||
Set a time before enabling notifications |
|||
</p> |
|||
</div> |
|||
</div> |
|||
|
|||
<!-- Loading state --> |
|||
<div v-if="loading" class="mt-2 text-sm text-slate-500">Loading...</div> |
|||
</section> |
|||
</template> |
|||
|
|||
<script lang="ts"> |
|||
/** |
|||
* DailyNotificationSection Component |
|||
* |
|||
* A self-contained component for managing daily notification scheduling |
|||
* in AccountViewView. This component handles platform detection, permission |
|||
* requests, scheduling, and state management for daily notifications. |
|||
* |
|||
* Features: |
|||
* - Platform capability detection (hides on unsupported platforms) |
|||
* - Permission request flow |
|||
* - Schedule/cancel notifications |
|||
* - Time editing with HTML5 time input |
|||
* - Settings persistence |
|||
* - Plugin state synchronization |
|||
* |
|||
* @author Generated for TimeSafari Daily Notification Integration |
|||
* @component |
|||
*/ |
|||
|
|||
import { Component, Vue } from "vue-facing-decorator"; |
|||
import { PlatformServiceMixin } from "@/utils/PlatformServiceMixin"; |
|||
import { logger } from "@/utils/logger"; |
|||
import { PlatformServiceFactory } from "@/services/PlatformServiceFactory"; |
|||
import type { |
|||
NotificationStatus, |
|||
PermissionStatus, |
|||
} from "@/services/PlatformService"; |
|||
import { createNotifyHelpers, TIMEOUTS } from "@/utils/notify"; |
|||
import type { NotificationIface } from "@/constants/app"; |
|||
|
|||
/** |
|||
* Convert 24-hour time format ("09:00") to 12-hour display format ("9:00 AM") |
|||
*/ |
|||
function formatTimeForDisplay(time24: string): string { |
|||
if (!time24) return ""; |
|||
const [hours, minutes] = time24.split(":"); |
|||
const hourNum = parseInt(hours); |
|||
const isPM = hourNum >= 12; |
|||
const displayHour = |
|||
hourNum === 0 ? 12 : hourNum > 12 ? hourNum - 12 : hourNum; |
|||
return `${displayHour}:${minutes} ${isPM ? "PM" : "AM"}`; |
|||
} |
|||
|
|||
@Component({ |
|||
name: "DailyNotificationSection", |
|||
mixins: [PlatformServiceMixin], |
|||
}) |
|||
export default class DailyNotificationSection extends Vue { |
|||
$notify!: (notification: NotificationIface, timeout?: number) => void; |
|||
|
|||
// Component state |
|||
notificationsSupported: boolean = false; |
|||
nativeNotificationEnabled: boolean = false; |
|||
nativeNotificationTime: string = ""; // Display format: "9:00 AM" |
|||
nativeNotificationTimeStorage: string = ""; // Plugin format: "09:00" |
|||
nativeNotificationTitle: string = "Daily Update"; |
|||
nativeNotificationMessage: string = "Your daily notification is ready!"; |
|||
showTimeEdit: boolean = false; |
|||
loading: boolean = false; |
|||
notificationStatus: NotificationStatus | null = null; |
|||
|
|||
// Notify helpers |
|||
private notify!: ReturnType<typeof createNotifyHelpers>; |
|||
|
|||
async created(): Promise<void> { |
|||
this.notify = createNotifyHelpers(this.$notify); |
|||
} |
|||
|
|||
/** |
|||
* Initialize component state on mount |
|||
* Checks platform support and syncs with plugin state |
|||
* |
|||
* **Token Refresh on Mount:** |
|||
* - Refreshes native fetcher configuration to ensure plugin has valid token |
|||
* - This handles cases where app was closed for extended periods |
|||
* - Token refresh happens automatically without user interaction |
|||
* |
|||
* **App Resume Listener:** |
|||
* - Listens for Capacitor 'resume' event to refresh token when app comes to foreground |
|||
* - Ensures plugin always has fresh token for background prefetch operations |
|||
* - Cleaned up in `beforeDestroy()` lifecycle hook |
|||
*/ |
|||
async mounted(): Promise<void> { |
|||
await this.initializeState(); |
|||
// Refresh native fetcher configuration on mount |
|||
// This ensures plugin has valid token even if app was closed for extended periods |
|||
await this.refreshNativeFetcherConfig(); |
|||
// Listen for app resume events to refresh token when app comes to foreground |
|||
// This is part of the proactive token refresh strategy |
|||
document.addEventListener("resume", this.handleAppResume); |
|||
} |
|||
|
|||
/** |
|||
* Cleanup on component destroy |
|||
*/ |
|||
beforeDestroy(): void { |
|||
document.removeEventListener("resume", this.handleAppResume); |
|||
} |
|||
|
|||
/** |
|||
* Handle app resume event - refresh native fetcher configuration |
|||
* |
|||
* This method is called when the app comes to foreground (via Capacitor 'resume' event). |
|||
* It proactively refreshes the JWT token to ensure the plugin has valid authentication |
|||
* for background prefetch operations. |
|||
* |
|||
* **Why refresh on resume?** |
|||
* - Tokens expire after 72 hours |
|||
* - App may have been closed for extended periods |
|||
* - Refreshing ensures plugin has valid token for next prefetch cycle |
|||
* - No user interaction required - happens automatically |
|||
* |
|||
* @see {@link refreshNativeFetcherConfig} For implementation details |
|||
*/ |
|||
async handleAppResume(): Promise<void> { |
|||
logger.debug( |
|||
"[DailyNotificationSection] App resumed, refreshing native fetcher config", |
|||
); |
|||
await this.refreshNativeFetcherConfig(); |
|||
} |
|||
|
|||
/** |
|||
* Refresh native fetcher configuration with fresh JWT token |
|||
* |
|||
* This method ensures the daily notification plugin has a valid authentication token |
|||
* for background prefetch operations. It's called proactively to prevent token expiration |
|||
* issues during offline periods. |
|||
* |
|||
* **Refresh Triggers:** |
|||
* - Component mount (when notification settings page loads) |
|||
* - App resume (when app comes to foreground) |
|||
* - Notification enabled (when user enables daily notifications) |
|||
* |
|||
* **Token Refresh Strategy (Hybrid Approach):** |
|||
* - Tokens are valid for 72 hours (see `accessTokenForBackground`) |
|||
* - Tokens are refreshed proactively when app is already open |
|||
* - If token expires while offline, plugin uses cached content |
|||
* - Next time app opens, token is automatically refreshed |
|||
* |
|||
* **Why This Approach?** |
|||
* - No app wake-up required (tokens refresh when app is already open) |
|||
* - Works offline (72-hour validity supports extended offline periods) |
|||
* - Automatic (no user interaction required) |
|||
* - Includes starred plans (fetcher receives user's starred plans for prefetch) |
|||
* - Graceful degradation (if refresh fails, cached content still works) |
|||
* |
|||
* **Error Handling:** |
|||
* - Errors are logged but not shown to user (background operation) |
|||
* - Returns early if notifications not supported or disabled |
|||
* - Returns early if API server not configured |
|||
* - Failures don't interrupt user experience |
|||
* |
|||
* @returns Promise that resolves when refresh completes (or fails silently) |
|||
* |
|||
* @example |
|||
* ```typescript |
|||
* // Called automatically on mount/resume |
|||
* await this.refreshNativeFetcherConfig(); |
|||
* ``` |
|||
* |
|||
* @see {@link CapacitorPlatformService.configureNativeFetcher} For token generation |
|||
* @see {@link accessTokenForBackground} For 72-hour token generation |
|||
*/ |
|||
async refreshNativeFetcherConfig(): Promise<void> { |
|||
try { |
|||
const platformService = PlatformServiceFactory.getInstance(); |
|||
|
|||
// Early return: Only refresh if notifications are supported and enabled |
|||
// This prevents unnecessary work when notifications aren't being used |
|||
if (!this.notificationsSupported || !this.nativeNotificationEnabled) { |
|||
return; |
|||
} |
|||
|
|||
// Get settings for API server and starred plans |
|||
// API server tells plugin where to fetch content from |
|||
// Starred plans tell plugin which plans to prefetch |
|||
const settings = await this.$accountSettings(); |
|||
const apiServer = settings.apiServer || ""; |
|||
|
|||
if (!apiServer) { |
|||
logger.warn( |
|||
"[DailyNotificationSection] No API server configured, skipping native fetcher refresh", |
|||
); |
|||
return; |
|||
} |
|||
|
|||
// Get starred plans from settings |
|||
// These are passed to the plugin so it knows which plans to prefetch |
|||
const starredPlanHandleIds = settings.starredPlanHandleIds || []; |
|||
|
|||
// Configure native fetcher with fresh token |
|||
// The jwt parameter is ignored - configureNativeFetcher generates it automatically |
|||
// This ensures we always have a fresh token with current expiration time |
|||
await platformService.configureNativeFetcher({ |
|||
apiServer, |
|||
jwt: "", // Will be generated automatically by configureNativeFetcher |
|||
starredPlanHandleIds, |
|||
}); |
|||
|
|||
logger.info( |
|||
"[DailyNotificationSection] Native fetcher configuration refreshed", |
|||
); |
|||
} catch (error) { |
|||
// Don't show error to user - this is a background operation |
|||
// Failures are logged for debugging but don't interrupt user experience |
|||
// If refresh fails, plugin will use existing token (if still valid) or cached content |
|||
logger.error( |
|||
"[DailyNotificationSection] Failed to refresh native fetcher config:", |
|||
error, |
|||
); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Initialize component state |
|||
* Checks platform support and syncs with plugin state |
|||
*/ |
|||
async initializeState(): Promise<void> { |
|||
try { |
|||
this.loading = true; |
|||
const platformService = PlatformServiceFactory.getInstance(); |
|||
|
|||
logger.debug( |
|||
"[DailyNotificationSection] Checking notification support...", |
|||
); |
|||
|
|||
// Check if notifications are supported on this platform |
|||
// This also verifies plugin availability (returns null if plugin unavailable) |
|||
const status = await platformService.getDailyNotificationStatus(); |
|||
if (status === null) { |
|||
// Notifications not supported or plugin unavailable - don't initialize |
|||
this.notificationsSupported = false; |
|||
logger.warn( |
|||
"[DailyNotificationSection] Notifications not supported or plugin unavailable - section will be hidden", |
|||
); |
|||
return; |
|||
} |
|||
|
|||
logger.debug( |
|||
"[DailyNotificationSection] Notifications supported, status:", |
|||
status, |
|||
); |
|||
|
|||
this.notificationsSupported = true; |
|||
this.notificationStatus = status; |
|||
|
|||
// Plugin state is the source of truth |
|||
if (status.isScheduled && status.scheduledTime) { |
|||
// Plugin has a scheduled notification - sync UI to match |
|||
this.nativeNotificationEnabled = true; |
|||
this.nativeNotificationTimeStorage = status.scheduledTime; |
|||
this.nativeNotificationTime = formatTimeForDisplay( |
|||
status.scheduledTime, |
|||
); |
|||
} else { |
|||
// No plugin schedule - UI defaults to disabled |
|||
this.nativeNotificationEnabled = false; |
|||
this.nativeNotificationTimeStorage = ""; |
|||
this.nativeNotificationTime = ""; |
|||
} |
|||
} catch (error) { |
|||
logger.error("[DailyNotificationSection] Failed to initialize:", error); |
|||
this.notificationsSupported = false; |
|||
} finally { |
|||
this.loading = false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Toggle notification on/off |
|||
*/ |
|||
async toggleNativeNotification(): Promise<void> { |
|||
// Prevent multiple simultaneous toggles |
|||
if (this.loading) { |
|||
logger.warn( |
|||
"[DailyNotificationSection] Toggle ignored - operation in progress", |
|||
); |
|||
return; |
|||
} |
|||
|
|||
logger.info( |
|||
`[DailyNotificationSection] Toggling notification: ${this.nativeNotificationEnabled} -> ${!this.nativeNotificationEnabled}`, |
|||
); |
|||
|
|||
if (this.nativeNotificationEnabled) { |
|||
await this.disableNativeNotification(); |
|||
} else { |
|||
await this.enableNativeNotification(); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Enable daily notification |
|||
*/ |
|||
async enableNativeNotification(): Promise<void> { |
|||
try { |
|||
this.loading = true; |
|||
const platformService = PlatformServiceFactory.getInstance(); |
|||
|
|||
// Check if we have a time set |
|||
if (!this.nativeNotificationTimeStorage) { |
|||
this.notify.error( |
|||
"Please set a notification time first", |
|||
TIMEOUTS.SHORT, |
|||
); |
|||
this.loading = false; |
|||
return; |
|||
} |
|||
|
|||
// Check permissions first - this also verifies plugin availability |
|||
let permissions: PermissionStatus | null; |
|||
try { |
|||
permissions = await platformService.checkNotificationPermissions(); |
|||
logger.info( |
|||
`[DailyNotificationSection] Permission check result:`, |
|||
permissions, |
|||
); |
|||
} catch (error) { |
|||
// Plugin may not be available or there's an error |
|||
logger.error( |
|||
"[DailyNotificationSection] Failed to check permissions (plugin may be unavailable):", |
|||
error, |
|||
); |
|||
this.notify.error( |
|||
"Unable to check notification permissions. The notification plugin may not be installed.", |
|||
TIMEOUTS.LONG, |
|||
); |
|||
this.nativeNotificationEnabled = false; |
|||
return; |
|||
} |
|||
|
|||
if (permissions === null) { |
|||
// Platform doesn't support notifications or plugin unavailable |
|||
logger.warn( |
|||
"[DailyNotificationSection] Notifications not supported or plugin unavailable", |
|||
); |
|||
this.notify.error( |
|||
"Notifications are not supported on this platform or the plugin is not installed.", |
|||
TIMEOUTS.SHORT, |
|||
); |
|||
this.nativeNotificationEnabled = false; |
|||
return; |
|||
} |
|||
|
|||
logger.info( |
|||
`[DailyNotificationSection] Permission state: ${permissions.notifications}`, |
|||
); |
|||
|
|||
// If permissions are explicitly denied, don't try to request again |
|||
// (this prevents the plugin crash when handling denied permissions) |
|||
// Android won't show the dialog again if permissions are permanently denied |
|||
if (permissions.notifications === "denied") { |
|||
logger.warn( |
|||
"[DailyNotificationSection] Permissions already denied, directing user to settings", |
|||
); |
|||
this.notify.error( |
|||
"Notification permissions were denied. Tap 'Open Settings' to enable them.", |
|||
TIMEOUTS.LONG, |
|||
); |
|||
this.nativeNotificationEnabled = false; |
|||
return; |
|||
} |
|||
|
|||
// Only request if permissions are in "prompt" state (not denied, not granted) |
|||
// This ensures we only call requestPermissions when Android will actually show a dialog |
|||
if (permissions.notifications === "prompt") { |
|||
logger.info( |
|||
"[DailyNotificationSection] Permission state is 'prompt', requesting permissions...", |
|||
); |
|||
try { |
|||
const result = await platformService.requestNotificationPermissions(); |
|||
logger.info( |
|||
`[DailyNotificationSection] Permission request result:`, |
|||
result, |
|||
); |
|||
if (result === null) { |
|||
// Plugin unavailable or request failed |
|||
logger.error( |
|||
"[DailyNotificationSection] Permission request returned null", |
|||
); |
|||
this.notify.error( |
|||
"Unable to request notification permissions. The plugin may not be available.", |
|||
TIMEOUTS.LONG, |
|||
); |
|||
this.nativeNotificationEnabled = false; |
|||
return; |
|||
} |
|||
if (!result.notifications) { |
|||
// Permission request was denied |
|||
logger.warn( |
|||
"[DailyNotificationSection] Permission request denied by user", |
|||
); |
|||
this.notify.error( |
|||
"Notification permissions are required. Tap 'Open Settings' to enable them.", |
|||
TIMEOUTS.LONG, |
|||
); |
|||
this.nativeNotificationEnabled = false; |
|||
return; |
|||
} |
|||
// Permissions granted - continue |
|||
logger.info( |
|||
"[DailyNotificationSection] Permissions granted successfully", |
|||
); |
|||
} catch (error) { |
|||
// Handle permission request errors (including plugin crashes) |
|||
logger.error( |
|||
"[DailyNotificationSection] Permission request failed:", |
|||
error, |
|||
); |
|||
this.notify.error( |
|||
"Unable to request notification permissions. Tap 'Open Settings' to enable them.", |
|||
TIMEOUTS.LONG, |
|||
); |
|||
this.nativeNotificationEnabled = false; |
|||
return; |
|||
} |
|||
} else if (permissions.notifications !== "granted") { |
|||
// Unexpected state - shouldn't happen, but handle gracefully |
|||
logger.warn( |
|||
`[DailyNotificationSection] Unexpected permission state: ${permissions.notifications}`, |
|||
); |
|||
this.notify.error( |
|||
"Unable to determine notification permission status. Tap 'Open Settings' to check.", |
|||
TIMEOUTS.LONG, |
|||
); |
|||
this.nativeNotificationEnabled = false; |
|||
return; |
|||
} else { |
|||
logger.info("[DailyNotificationSection] Permissions already granted"); |
|||
} |
|||
|
|||
// Permissions are granted - continue with scheduling |
|||
|
|||
// Schedule notification via PlatformService |
|||
await platformService.scheduleDailyNotification({ |
|||
time: this.nativeNotificationTimeStorage, // "09:00" in local time |
|||
title: this.nativeNotificationTitle, |
|||
body: this.nativeNotificationMessage, |
|||
sound: true, |
|||
priority: "high", |
|||
}); |
|||
|
|||
// Update UI state |
|||
this.nativeNotificationEnabled = true; |
|||
|
|||
// Refresh native fetcher configuration with fresh token |
|||
// This ensures plugin has valid authentication when notifications are first enabled |
|||
// Token will be valid for 72 hours, supporting offline prefetch operations |
|||
await this.refreshNativeFetcherConfig(); |
|||
|
|||
this.notify.success( |
|||
"Daily notification scheduled successfully", |
|||
TIMEOUTS.SHORT, |
|||
); |
|||
} catch (error) { |
|||
logger.error( |
|||
"[DailyNotificationSection] Failed to enable notification:", |
|||
error, |
|||
); |
|||
this.notify.error( |
|||
"Failed to schedule notification. Please try again.", |
|||
TIMEOUTS.LONG, |
|||
); |
|||
this.nativeNotificationEnabled = false; |
|||
} finally { |
|||
this.loading = false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Disable daily notification |
|||
*/ |
|||
async disableNativeNotification(): Promise<void> { |
|||
try { |
|||
this.loading = true; |
|||
const platformService = PlatformServiceFactory.getInstance(); |
|||
|
|||
// Cancel notification via PlatformService |
|||
await platformService.cancelDailyNotification(); |
|||
|
|||
// Update UI state |
|||
this.nativeNotificationEnabled = false; |
|||
this.nativeNotificationTime = ""; |
|||
this.nativeNotificationTimeStorage = ""; |
|||
this.showTimeEdit = false; |
|||
|
|||
this.notify.success("Daily notification disabled", TIMEOUTS.SHORT); |
|||
} catch (error) { |
|||
logger.error( |
|||
"[DailyNotificationSection] Failed to disable notification:", |
|||
error, |
|||
); |
|||
this.notify.error( |
|||
"Failed to disable notification. Please try again.", |
|||
TIMEOUTS.LONG, |
|||
); |
|||
} finally { |
|||
this.loading = false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Show/hide time edit input |
|||
*/ |
|||
editNativeNotificationTime(): void { |
|||
this.showTimeEdit = !this.showTimeEdit; |
|||
} |
|||
|
|||
/** |
|||
* Handle time input change |
|||
*/ |
|||
onTimeChange(): void { |
|||
// Time is already in nativeNotificationTimeStorage via v-model |
|||
// Just update display format |
|||
if (this.nativeNotificationTimeStorage) { |
|||
this.nativeNotificationTime = formatTimeForDisplay( |
|||
this.nativeNotificationTimeStorage, |
|||
); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Save time change and update notification schedule |
|||
*/ |
|||
async saveTimeChange(): Promise<void> { |
|||
if (!this.nativeNotificationTimeStorage) { |
|||
this.notify.error("Please select a time", TIMEOUTS.SHORT); |
|||
return; |
|||
} |
|||
|
|||
// Update display format |
|||
this.nativeNotificationTime = formatTimeForDisplay( |
|||
this.nativeNotificationTimeStorage, |
|||
); |
|||
|
|||
// If notification is enabled, update the schedule |
|||
if (this.nativeNotificationEnabled) { |
|||
await this.updateNotificationTime(this.nativeNotificationTimeStorage); |
|||
} else { |
|||
// Just update local state (time preference stored in component) |
|||
this.showTimeEdit = false; |
|||
this.notify.success("Notification time saved", TIMEOUTS.SHORT); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Update notification time |
|||
* If notification is enabled, immediately updates the schedule |
|||
*/ |
|||
async updateNotificationTime(newTime: string): Promise<void> { |
|||
// newTime is in "HH:mm" format from HTML5 time input |
|||
if (!this.nativeNotificationEnabled) { |
|||
// If notification is disabled, just update local state |
|||
this.nativeNotificationTimeStorage = newTime; |
|||
this.nativeNotificationTime = formatTimeForDisplay(newTime); |
|||
this.showTimeEdit = false; |
|||
return; |
|||
} |
|||
|
|||
// Notification is enabled - update the schedule |
|||
try { |
|||
this.loading = true; |
|||
const platformService = PlatformServiceFactory.getInstance(); |
|||
|
|||
// 1. Cancel existing notification |
|||
await platformService.cancelDailyNotification(); |
|||
|
|||
// 2. Schedule with new time |
|||
await platformService.scheduleDailyNotification({ |
|||
time: newTime, // "09:00" in local time |
|||
title: this.nativeNotificationTitle, |
|||
body: this.nativeNotificationMessage, |
|||
sound: true, |
|||
priority: "high", |
|||
}); |
|||
|
|||
// 3. Update local state |
|||
this.nativeNotificationTimeStorage = newTime; |
|||
this.nativeNotificationTime = formatTimeForDisplay(newTime); |
|||
|
|||
this.notify.success( |
|||
"Notification time updated successfully", |
|||
TIMEOUTS.SHORT, |
|||
); |
|||
this.showTimeEdit = false; |
|||
} catch (error) { |
|||
logger.error( |
|||
"[DailyNotificationSection] Failed to update notification time:", |
|||
error, |
|||
); |
|||
this.notify.error( |
|||
"Failed to update notification time. Please try again.", |
|||
TIMEOUTS.LONG, |
|||
); |
|||
} finally { |
|||
this.loading = false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Show info dialog about native notifications |
|||
*/ |
|||
showNativeNotificationInfo(): void { |
|||
// TODO: Implement info dialog or navigate to help page |
|||
this.notify.info( |
|||
"Daily notifications use your device's native notification system. They work even when the app is closed.", |
|||
TIMEOUTS.STANDARD, |
|||
); |
|||
} |
|||
|
|||
/** |
|||
* Open app notification settings |
|||
*/ |
|||
async openNotificationSettings(): Promise<void> { |
|||
try { |
|||
const platformService = PlatformServiceFactory.getInstance(); |
|||
const result = await platformService.openAppNotificationSettings(); |
|||
if (result === null) { |
|||
this.notify.error( |
|||
"Unable to open settings. Please go to Settings > Apps > TimeSafari > Notifications manually.", |
|||
TIMEOUTS.LONG, |
|||
); |
|||
} else { |
|||
this.notify.success("Opening notification settings...", TIMEOUTS.SHORT); |
|||
} |
|||
} catch (error) { |
|||
logger.error( |
|||
"[DailyNotificationSection] Failed to open notification settings:", |
|||
error, |
|||
); |
|||
this.notify.error( |
|||
"Unable to open settings. Please go to Settings > Apps > TimeSafari > Notifications manually.", |
|||
TIMEOUTS.LONG, |
|||
); |
|||
} |
|||
} |
|||
} |
|||
</script> |
|||
|
|||
<style scoped> |
|||
.dot { |
|||
transition: left 0.2s ease; |
|||
} |
|||
</style> |
|||
@ -1,4 +1,21 @@ |
|||
import { defineConfig } from "vite"; |
|||
import { createBuildConfig } from "./vite.config.common.mts"; |
|||
|
|||
export default defineConfig(async () => createBuildConfig('capacitor')); |
|||
export default defineConfig(async () => { |
|||
const baseConfig = await createBuildConfig('capacitor'); |
|||
|
|||
return { |
|||
...baseConfig, |
|||
build: { |
|||
...baseConfig.build, |
|||
rollupOptions: { |
|||
...baseConfig.build?.rollupOptions, |
|||
// Note: @timesafari/daily-notification-plugin is NOT externalized |
|||
// because it needs to be bundled for dynamic imports to work in Capacitor WebView |
|||
output: { |
|||
...baseConfig.build?.rollupOptions?.output, |
|||
} |
|||
} |
|||
} |
|||
}; |
|||
}); |
|||
Loading…
Reference in new issue