create-flutterinit 0.1.0

package/templates/overlays/utilities/geolocator/lib/src/services/(usesGeolocator)@location_service.dart.hbs

@@ -0,0 +1,78 @@
+import 'package:geolocator/geolocator.dart';
+import '../utils/utils.dart';
+
+/// A service to handle device location requests and status checks.
+class LocationService {
+  LocationService._();
+  static final LocationService instance = LocationService._();
+
+  /// Check the status of location permission.
+  FutureEither<LocationPermission> checkPermission() async {
+    return runTask(() => Geolocator.checkPermission());
+  }
+
+  /// Request location permission.
+  FutureEither<LocationPermission> requestPermission() async {
+    return runTask(() => Geolocator.requestPermission());
+  }
+
+  /// Check if location services are enabled.
+  FutureEither<bool> isLocationServiceEnabled() async {
+    return runTask(() => Geolocator.isLocationServiceEnabled());
+  }
+
+  /// Open the location settings.
+  FutureEither<bool> openLocationSettings() async {
+    return runTask(() => Geolocator.openLocationSettings());
+  }
+
+  /// Get the current position.
+  FutureEither<Position> getCurrentPosition({
+    LocationAccuracy accuracy = LocationAccuracy.high,
+  }) async {
+    return runTask(() async {
+      bool serviceEnabled;
+      LocationPermission permission;
+
+      serviceEnabled = await Geolocator.isLocationServiceEnabled();
+      if (!serviceEnabled) {
+        throw Exception('Location services are disabled.');
+      }
+
+      permission = await Geolocator.checkPermission();
+      if (permission == LocationPermission.denied) {
+        permission = await Geolocator.requestPermission();
+        if (permission == LocationPermission.denied) {
+          throw Exception('Location permissions are denied.');
+        }
+      }
+      
+      if (permission == LocationPermission.deniedForever) {
+        throw Exception(
+            'Location permissions are permanently denied, we cannot request permissions.');
+      } 
+
+      return await Geolocator.getCurrentPosition(
+        locationSettings: LocationSettings(accuracy: accuracy),
+      );
+    });
+  }
+
+  /// Get the last known position.
+  FutureEither<Position?> getLastKnownPosition() async {
+    return runTask(() => Geolocator.getLastKnownPosition());
+  }
+
+  /// Get a stream of position updates.
+  Stream<Position> getPositionStream({
+    LocationAccuracy accuracy = LocationAccuracy.high,
+    int distanceFilter = 0,
+  }) {
+    return Geolocator.getPositionStream(
+      locationSettings: LocationSettings(
+        accuracy: accuracy,
+        distanceFilter: distanceFilter,
+      ),
+    );
+  }
+}

package/templates/overlays/utilities/path_provider/lib/src/services/(usesPathProvider)@path_service.dart.hbs

@@ -0,0 +1,30 @@
+import 'dart:io';
+import 'package:path_provider/path_provider.dart';
+import '../utils/utils.dart';
+
+/// A service to easily access platform-specific file system locations.
+class PathService {
+  PathService._();
+  static final PathService instance = PathService._();
+
+  /// Get the directory where the application may place data that is user-generated.
+  FutureEither<Directory> getDocumentsDirectory() async => 
+      runTask(() => getApplicationDocumentsDirectory());
+
+  /// Get the directory where the application may place application-specific cache files.
+  FutureEither<Directory> getTempDirectory() async => 
+      runTask(() => getTemporaryDirectory());
+
+  /// Get the directory where the application may place data that is specific to 
+  /// the application and not meant to be seen by the user.
+  FutureEither<Directory> getAppSupportDirectory() async => 
+      runTask(() => getApplicationSupportDirectory());
+
+  /// Get the directory where current application-specific data may be found.
+  FutureEither<Directory> getAppLibraryDirectory() async => 
+      runTask(() => getLibraryDirectory());
+
+  /// Get the path to the external storage directory (Android only).
+  FutureEither<Directory?> getExternalStorageDirectoryPath() async => 
+      runTask(() => getExternalStorageDirectory());
+}

package/templates/overlays/utilities/permission_handler/lib/src/services/(usesPermissionHandler)@permission_service.dart.hbs

@@ -0,0 +1,28 @@
+import 'package:permission_handler/permission_handler.dart';
+import '../utils/utils.dart';
+
+/// A service to handle device permission requests and status checks.
+class PermissionService {
+  PermissionService._();
+  static final PermissionService instance = PermissionService._();
+
+  /// Check the status of a specific permission.
+  FutureEither<PermissionStatus> checkStatus(Permission permission) async {
+    return runTask(() => permission.status);
+  }
+
+  /// Request a specific permission.
+  FutureEither<PermissionStatus> request(Permission permission) async {
+    return runTask(() => permission.request());
+  }
+
+  /// Request multiple permissions at once.
+  FutureEither<Map<Permission, PermissionStatus>> requestMultiple(List<Permission> permissions) async {
+    return runTask(() => permissions.request());
+  }
+
+  /// Open the app settings.
+  FutureEither<bool> openSettings() async {
+    return runTask(() => openAppSettings());
+  }
+}

package/templates/overlays/utilities/permission_handler/lib/src/shared/hooks/use_permission.dart.hbs

@@ -0,0 +1,44 @@
+{{#if flags.usesFlutterHooks}}
+import 'package:flutter_hooks/flutter_hooks.dart';
+import 'package:permission_handler/permission_handler.dart';
+import '../../services/permission_service.dart';
+
+/// A hook to manage permission lifecycle and status with loading state.
+(PermissionStatus, bool, Future<void> Function()) usePermission(Permission permission) {
+  final status = useState<PermissionStatus>(PermissionStatus.denied);
+  final isLoading = useState(false);
+
+  Future<void> check() async {
+    isLoading.value = true;
+    try {
+      final result = await PermissionService.instance.checkStatus(permission);
+      result.fold(
+        (f) => null,
+        (s) => status.value = s,
+      );
+    } finally {
+      isLoading.value = false;
+    }
+  }
+
+  Future<void> request() async {
+    isLoading.value = true;
+    try {
+      final result = await PermissionService.instance.request(permission);
+      result.fold(
+        (f) => null,
+        (s) => status.value = s,
+      );
+    } finally {
+      isLoading.value = false;
+    }
+  }
+
+  useEffect(() {
+    check();
+    return null;
+  }, [permission]);
+
+  return (status.value, isLoading.value, request);
+}
+{{/if}}

package/templates/overlays/utilities/share_plus/lib/src/services/(usesSharePlus)@share_service.dart.hbs

@@ -0,0 +1,22 @@
+import 'package:share_plus/share_plus.dart';
+import '../utils/utils.dart';
+
+/// A service to handle sharing content via the platform's native share dialog.
+class ShareService {
+  ShareService._();
+  static final ShareService instance = ShareService._();
+
+  /// Share plain text content.
+  FutureEither<ShareResult> shareText(String text, {String? subject}) async {
+    return runTask(() => Share.share(text, subject: subject));
+  }
+
+  /// Share files.
+  FutureEither<ShareResult> shareFiles(List<String> paths, {String? text, String? subject}) async {
+    return runTask(() => Share.shareXFiles(
+      paths.map((p) => XFile(p)).toList(),
+      text: text,
+      subject: subject,
+    ));
+  }
+}

package/templates/overlays/utilities/share_plus/lib/src/shared/hooks/use_share.dart.hbs

@@ -0,0 +1,26 @@
+{{#if flags.usesFlutterHooks}}
+import 'package:flutter_hooks/flutter_hooks.dart';
+import '../../utils/utils.dart';
+import '../../services/share_service.dart';
+
+/// A hook to simplify sharing logic within widgets with loading state.
+(bool, Future<void> Function(String, {String? subject})) useShare() {
+  final isLoading = useState(false);
+  final service = ShareService.instance;
+
+  Future<void> share(String text, {String? subject}) async {
+    isLoading.value = true;
+    try {
+      final result = await service.shareText(text, subject: subject);
+      result.fold(
+        (failure) => AppLogger.error('Sharing failed: ${failure.message}'),
+        (success) => AppLogger.info('Sharing result: ${success.status}'),
+      );
+    } finally {
+      isLoading.value = false;
+    }
+  }
+
+  return (isLoading.value, share);
+}
+{{/if}}

package/templates/overlays/utilities/url_launcher/lib/src/services/(usesUrlLauncher)@url_launcher_service.dart.hbs

@@ -0,0 +1,37 @@
+import 'dart:io';
+import '../imports/imports.dart';
+
+/// A service to handle URL launching operations.
+class UrlLauncherService {
+  UrlLauncherService._();
+  static final UrlLauncherService instance = UrlLauncherService._();
+
+  /// Launch a URL string.
+  FutureEither<void> launch(String url, {LaunchMode? mode}) async {
+    return runTask(() async {
+      final formattedUrl = _formatUrl(url);
+      final uri = Uri.parse(formattedUrl);
+
+      if (await canLaunchUrl(uri)) {
+        await launchUrl(
+          uri,
+          mode: mode ?? LaunchMode.externalApplication,
+        );
+      } else {
+        throw Exception('Could not launch url: $formattedUrl');
+      }
+    });
+  }
+
+  String _formatUrl(String url) {
+    if (url.isValidUrl && !url.contains('://')) {
+      return 'https://$url';
+    }
+    if (url.isValidPhoneNumber) {
+      return Platform.isAndroid
+          ? 'whatsapp://send?phone=$url'
+          : 'https://wa.me/$url';
+    }
+    return url;
+  }
+}

package/templates/overlays/utilities/url_launcher/lib/src/shared/hooks/use_launch_url.dart.hbs

@@ -0,0 +1,52 @@
+{{#if flags.usesFlutterHooks}}
+import 'dart:io'; 
+import '../../imports/imports.dart';
+
+/// A hook to handle URL launching with state feedback.
+(bool, Future<void> Function(String)) useLaunchUrl({LaunchMode? mode}) {
+  final isLoading = useState(false);
+
+  Future<void> launch(String url) async {
+    isLoading.value = true;
+    try {
+      final formattedUrl = _formatUrl(url);
+      final uri = Uri.parse(formattedUrl);
+
+      if (await canLaunchUrl(uri)) {
+        await launchUrl(
+          uri,
+          mode: mode ?? LaunchMode.externalApplication,
+        );
+      } else {
+        AppLogger.error('Could not launch url: $formattedUrl');
+        showGlobalToast(
+          message: 'Could not launch url',
+          status: 'error',
+        );
+      }
+    } catch (e) {
+      AppLogger.error('Error launching URL: $e');
+      showGlobalToast(
+        message: 'Could not launch url',
+        status: 'error',
+      );
+    } finally {
+      isLoading.value = false;
+    }
+  }
+
+  return (isLoading.value, launch);
+}
+
+String _formatUrl(String url) {
+  if (url.isValidUrl && !url.contains('://')) {
+    return 'https://$url';
+  }
+  if (url.isValidPhoneNumber) {
+    return Platform.isAndroid
+        ? 'whatsapp://send?phone=$url'
+        : 'https://wa.me/$url';
+  }
+  return url;
+}
+{{/if}}