check update

flutter_app/lib/services/storage_service.dart

@@ -51,4 +51,15 @@ class StorageService {
     final prefs = await SharedPreferences.getInstance();
     await prefs.setDouble(_customAuecKey, amount);
   }
+
+  // Generic string storage methods for update checking
+  Future<String?> getString(String key) async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(key);
+  }
+
+  Future<void> setString(String key, String value) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(key, value);
+  }
 }

flutter_app/lib/services/update_service.dart

@@ -0,0 +1,255 @@
+import 'package:flutter/foundation.dart';
+import 'package:http/http.dart' as http;
+import 'package:package_info_plus/package_info_plus.dart';
+import 'package:xml/xml.dart';
+
+class UpdateService {
+  static const String _releasesRssUrl = 'https://git.hudsonriggs.systems/LambdaBankingConglomerate/rmtPocketWatcher/releases.rss';
+  
+  /// Check if an update is available by comparing current version with latest release
+  Future<UpdateInfo?> checkForUpdates() async {
+    try {
+      // Get current app version
+      final packageInfo = await PackageInfo.fromPlatform();
+      final currentVersion = packageInfo.version;
+      
+      if (kDebugMode) {
+        print('Current app version: $currentVersion');
+        print('Checking for updates at: $_releasesRssUrl');
+      }
+      
+      // Fetch latest release from Gitea RSS feed
+      final response = await http.get(
+        Uri.parse(_releasesRssUrl),
+        headers: {
+          'Accept': 'application/rss+xml, application/xml, text/xml',
+          'User-Agent': 'rmtPocketWatcher/$currentVersion',
+        },
+      );
+      
+      if (response.statusCode == 200) {
+        final document = XmlDocument.parse(response.body);
+        final items = document.findAllElements('item');
+        
+        if (items.isEmpty) {
+          if (kDebugMode) {
+            print('No releases found in RSS feed');
+          }
+          return null;
+        }
+        
+        // Get the latest release (first item in RSS feed)
+        final latestItem = items.first;
+        final title = latestItem.findElements('title').first.innerText;
+        final link = latestItem.findElements('link').first.innerText;
+        final description = latestItem.findElements('description').firstOrNull?.innerText ?? '';
+        final pubDate = latestItem.findElements('pubDate').first.innerText;
+        
+        // Extract version from title (assuming format like "v1.2.3" or "Release v1.2.3")
+        final versionMatch = RegExp(r'v?(\d+\.\d+\.\d+)').firstMatch(title);
+        if (versionMatch == null) {
+          if (kDebugMode) {
+            print('Could not extract version from title: $title');
+          }
+          return null;
+        }
+        
+        final latestVersion = versionMatch.group(1)!;
+        
+        if (kDebugMode) {
+          print('Latest release version: $latestVersion');
+          print('Release title: $title');
+        }
+        
+        // Compare versions
+        if (isNewerVersion(latestVersion, currentVersion)) {
+          return UpdateInfo(
+            currentVersion: currentVersion,
+            latestVersion: latestVersion,
+            releaseUrl: link,
+            releaseName: title,
+            releaseNotes: description,
+            publishedAt: _parseRssDate(pubDate),
+            assets: _generateAssetUrls(latestVersion), // Generate expected asset URLs
+          );
+        } else {
+          if (kDebugMode) {
+            print('App is up to date');
+          }
+          return null;
+        }
+      } else {
+        if (kDebugMode) {
+          print('Failed to fetch RSS feed: ${response.statusCode}');
+          print('Response: ${response.body}');
+        }
+        return null;
+      }
+    } catch (e) {
+      if (kDebugMode) {
+        print('Error checking for updates: $e');
+      }
+      return null;
+    }
+  }
+  
+  /// Extract version number from git tag (e.g., "v1.2.3" -> "1.2.3")
+  @visibleForTesting
+  String extractVersionFromTag(String tag) {
+    return tag.startsWith('v') ? tag.substring(1) : tag;
+  }
+  
+  /// Compare two version strings (e.g., "1.2.3" vs "1.2.2")
+  @visibleForTesting
+  bool isNewerVersion(String latest, String current) {
+    final latestParts = latest.split('.').map(int.parse).toList();
+    final currentParts = current.split('.').map(int.parse).toList();
+    
+    // Ensure both have same number of parts
+    while (latestParts.length < currentParts.length) {
+      latestParts.add(0);
+    }
+    while (currentParts.length < latestParts.length) {
+      currentParts.add(0);
+    }
+    
+    for (int i = 0; i < latestParts.length; i++) {
+      if (latestParts[i] > currentParts[i]) {
+        return true;
+      } else if (latestParts[i] < currentParts[i]) {
+        return false;
+      }
+    }
+    
+    return false; // Versions are equal
+  }
+  
+  /// Parse RSS date format to DateTime
+  DateTime _parseRssDate(String rssDate) {
+    try {
+      // RSS dates are typically in RFC 2822 format
+      // Example: "Mon, 02 Jan 2006 15:04:05 MST"
+      return DateTime.parse(rssDate);
+    } catch (e) {
+      if (kDebugMode) {
+        print('Failed to parse RSS date: $rssDate, error: $e');
+      }
+      return DateTime.now();
+    }
+  }
+  
+  /// Generate expected asset URLs based on version and platform
+  List<ReleaseAsset> _generateAssetUrls(String version) {
+    final baseUrl = 'https://git.hudsonriggs.systems/LambdaBankingConglomerate/rmtPocketWatcher/releases/download/v$version';
+    
+    return [
+      ReleaseAsset(
+        name: 'rmtPocketWatcher-windows-x64.exe',
+        downloadUrl: '$baseUrl/rmtPocketWatcher-windows-x64.exe',
+        size: 0, // Unknown size from RSS
+        contentType: 'application/octet-stream',
+      ),
+      ReleaseAsset(
+        name: 'rmtPocketWatcher-windows-x64.msi',
+        downloadUrl: '$baseUrl/rmtPocketWatcher-windows-x64.msi',
+        size: 0,
+        contentType: 'application/octet-stream',
+      ),
+      ReleaseAsset(
+        name: 'rmtPocketWatcher-macos.dmg',
+        downloadUrl: '$baseUrl/rmtPocketWatcher-macos.dmg',
+        size: 0,
+        contentType: 'application/octet-stream',
+      ),
+      ReleaseAsset(
+        name: 'rmtPocketWatcher-linux.appimage',
+        downloadUrl: '$baseUrl/rmtPocketWatcher-linux.appimage',
+        size: 0,
+        contentType: 'application/octet-stream',
+      ),
+      ReleaseAsset(
+        name: 'rmtPocketWatcher-android.apk',
+        downloadUrl: '$baseUrl/rmtPocketWatcher-android.apk',
+        size: 0,
+        contentType: 'application/vnd.android.package-archive',
+      ),
+    ];
+  }
+}
+
+class UpdateInfo {
+  final String currentVersion;
+  final String latestVersion;
+  final String releaseUrl;
+  final String releaseName;
+  final String releaseNotes;
+  final DateTime publishedAt;
+  final List<ReleaseAsset> assets;
+  
+  UpdateInfo({
+    required this.currentVersion,
+    required this.latestVersion,
+    required this.releaseUrl,
+    required this.releaseName,
+    required this.releaseNotes,
+    required this.publishedAt,
+    required this.assets,
+  });
+  
+  /// Get the appropriate download asset for the current platform
+  ReleaseAsset? getAssetForCurrentPlatform() {
+    if (kIsWeb) return null;
+    
+    String platformPattern;
+    switch (defaultTargetPlatform) {
+      case TargetPlatform.windows:
+        platformPattern = r'windows|win|\.exe$|\.msi$';
+        break;
+      case TargetPlatform.macOS:
+        platformPattern = r'macos|mac|darwin|\.dmg$|\.pkg$';
+        break;
+      case TargetPlatform.linux:
+        platformPattern = r'linux|\.deb$|\.rpm$|\.appimage$';
+        break;
+      case TargetPlatform.android:
+        platformPattern = r'android|\.apk$';
+        break;
+      case TargetPlatform.iOS:
+        platformPattern = r'ios|\.ipa$';
+        break;
+      default:
+        return null;
+    }
+    
+    final regex = RegExp(platformPattern, caseSensitive: false);
+    
+    for (final asset in assets) {
+      if (regex.hasMatch(asset.name)) {
+        return asset;
+      }
+    }
+    
+    return null;
+  }
+}
+
+class ReleaseAsset {
+  final String name;
+  final String downloadUrl;
+  final int size;
+  final String contentType;
+  
+  ReleaseAsset({
+    required this.name,
+    required this.downloadUrl,
+    required this.size,
+    required this.contentType,
+  });
+  
+  String get formattedSize {
+    if (size < 1024) return '${size}B';
+    if (size < 1024 * 1024) return '${(size / 1024).toStringAsFixed(1)}KB';
+    if (size < 1024 * 1024 * 1024) return '${(size / (1024 * 1024)).toStringAsFixed(1)}MB';
+    return '${(size / (1024 * 1024 * 1024)).toStringAsFixed(1)}GB';
+  }
+}