v1.2.0+54

- screaming_possum.gif

lib/services/api_service.dart

@@ -1,111 +1,94 @@
-import 'dart:async';
-import 'dart:convert';
+import 'package:flutter/material.dart';
 
-import 'package:http/http.dart' as http;
-import 'package:flutter_secure_storage/flutter_secure_storage.dart';
+import 'package:get/get.dart';
 
 import 'package:f0ckapp/models/mediaitem_model.dart';
-import 'package:f0ckapp/models/suggestion_model.dart';
 
-final FlutterSecureStorage storage = const FlutterSecureStorage(
-  aOptions: AndroidOptions(encryptedSharedPreferences: true),
-);
+const List<String> mediaTypes = ["alles", "image", "video", "audio"];
+const List<String> mediaModes = ["sfw", "nsfw", "untagged", "all"];
 
-Future<List<MediaItem>> fetchMedia({
-  int? older,
-  String type = 'image',
-  int mode = 0,
-  bool random = false,
-  String? tag,
-}) async {
-  final Uri url = Uri.parse('https://api.f0ck.me/items/get').replace(
-    queryParameters: {
-      'type': type,
-      'mode': mode.toString(),
-      'random': (random ? 1 : 0).toString(),
-      if (tag != null) 'tag': tag,
-      if (older != null) 'older': older.toString(),
-    },
-  );
+class ApiService extends GetConnect {
+  RxList<MediaItem> mediaItems = <MediaItem>[].obs;
+  RxnString tag = RxnString();
+  RxInt type = 0.obs;
+  RxInt mode = 0.obs;
+  RxBool random = false.obs;
 
-  final http.Response response = await http.get(url);
-  if (response.statusCode == 200) {
-    final List<dynamic> jsonList = jsonDecode(response.body);
-    return jsonList.map((item) => MediaItem.fromJson(item)).toList();
-  } else {
-    throw Exception('Fehler beim Abrufen der Medien: ${response.statusCode}');
+  bool _isFetching = false;
+  DateTime? _lastFetchTime;
+  final Duration _minFetchInterval = Duration(milliseconds: 500);
+
+  @override
+  void onInit() {
+    super.onInit();
+    everAll([tag, type, mode, random], (_) => fetchMedia(reset: true));
   }
-}
 
-Future<MediaItem> fetchMediaDetail(int itemId) async {
-  final Uri url = Uri.parse('https://api.f0ck.me/item/${itemId.toString()}');
-
-  final http.Response response = await http.get(url);
-  if (response.statusCode == 200) {
-    final Map<String, dynamic> jsonResponse = jsonDecode(response.body);
-
-    return MediaItem.fromJson(jsonResponse);
-  } else {
-    throw Exception(
-      'Fehler beim Abrufen der Media-Details: ${response.statusCode}',
-    );
+  Future<void> setTag(String? newTag) async {
+    tag.value = newTag;
+    return await fetchMedia(reset: true);
   }
-}
 
-Future<List<Suggestion>> fetchSuggestions(String query) async {
-  final Uri uri = Uri.parse('https://api.f0ck.me/search/?q=$query');
-  try {
-    final http.Response response = await http
-        .get(uri)
-        .timeout(const Duration(seconds: 5));
+  Future<void> setType(int newType) async {
+    type.value = newType >= 0 && newType < mediaTypes.length ? newType : 0;
+    return await fetchMedia(reset: true);
+  }
 
-    if (response.statusCode == 200) {
-      final dynamic decoded = jsonDecode(response.body);
-      if (decoded is List) {
-        final suggestions = decoded
-            .map((item) => Suggestion.fromJson(item as Map<String, dynamic>))
-            .toList();
-        suggestions.sort((a, b) => b.score.compareTo(a.score));
-        return suggestions;
-      } else {
-        throw Exception('Unerwartetes Format: Es wurde eine Liste erwartet.');
+  Future<void> setMode(int newMode) async {
+    mode.value = newMode >= 0 && newMode < mediaModes.length ? newMode : 0;
+    return await fetchMedia(reset: true);
+  }
+
+  Future<void> toggleRandom() async {
+    random.value = !random.value;
+    return await fetchMedia(reset: true);
+  }
+
+  Future fetchMedia({int? id, bool reset = false}) async {
+    if (!reset) {
+      if (_isFetching) return;
+      if (_lastFetchTime != null &&
+          DateTime.now().difference(_lastFetchTime!) < _minFetchInterval) {
+        return;
       }
-    } else if (response.statusCode == 400) {
-      final dynamic error = jsonDecode(response.body);
-      final String message = error is Map<String, dynamic>
-          ? error['detail']?.toString() ?? 'Unbekannter Fehler.'
-          : 'Unbekannter Fehler.';
-      throw Exception('Client-Fehler 400: $message');
-    } else {
-      throw Exception(
-        'Fehler beim Abrufen der Vorschläge: ${response.statusCode}',
-      );
     }
-  } on TimeoutException {
-    throw Exception('Anfrage an die API hat zu lange gedauert.');
-  } catch (e) {
-    throw Exception('Fehler bei der Verarbeitung der Anfrage: $e');
-  }
-}
-
-Future<bool> login(String username, String password) async {
-  final Uri url = Uri.parse('https://api.f0ck.me/login');
-
-  final http.Response response = await http.post(
-    url,
-    body: {'username': username, 'password': password},
-  );
-
-  if (response.statusCode == 200) {
-    final dynamic data = jsonDecode(response.body);
-    final token = data['token'];
-    if (token != null) {
-      await storage.write(key: "token", value: token);
-      return true;
-    } else {
-      throw Exception('Token nicht im Response enthalten.');
-    }
-  } else {
-    throw Exception('Login fehlgeschlagen: ${response.statusCode}');
+    _lastFetchTime = DateTime.now();
+    _isFetching = true;
+
+    if (reset) mediaItems.clear();
+
+    final int? older =
+        id ?? (mediaItems.isNotEmpty ? mediaItems.last.id : null);
+    final Uri url = Uri.parse('https://api.f0ck.me/items/get').replace(
+      queryParameters: {
+        'type': mediaTypes[type.value],
+        'mode': mode.value.toString(),
+        'random': (random.value ? 1 : 0).toString(),
+        if (tag.value != null) 'tag': tag.value,
+        if (older != null) 'older': older.toString(),
+      },
+    );
+
+    try {
+      final Response<dynamic> response = await get(url.toString());
+
+      if (response.isOk && response.body is List) {
+        List<MediaItem> newMedia = (response.body as List)
+            .map((json) => MediaItem.fromJson(json))
+            .toList();
+
+        if (reset) {
+          mediaItems.assignAll(newMedia);
+        } else {
+          mediaItems.addAll(newMedia);
+        }
+      } else {
+        debugPrint('Fehler beim Laden der MediaItems: ${response.statusText}');
+      }
+    } catch (e) {
+      debugPrint('Exception beim Laden der MediaItems: $e');
+    } finally {
+      _isFetching = false;
+    }
   }
 }