location_selection_bloc.dart

Go to the documentation of this file.

import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import 'package:google_maps_flutter/google_maps_flutter.dart';
import 'package:geolocator/geolocator.dart';
import 'package:geocoding/geocoding.dart';
 
part 'location_selection_event.dart';
part 'location_selection_state.dart';
 
class LocationSelectionBloc extends Bloc<LocationSelectionEvent, LocationSelectionState> {
  LocationSelectionBloc() : super(LocationSelectionInitial()) {
    on<GetCurrentLocationEvent>(_onGetCurrentLocation);
    on<UpdateLocationEvent>(_onUpdateLocation);
    on<GetAddressFromLocationEvent>(_onGetAddressFromLocation);
    on<SelectSavedLocationEvent>(_onSelectSavedLocation);
    on<ConfirmLocationEvent>(_onConfirmLocation);
    on<ResetLocationSelectionEvent>(_onResetLocationSelection);
  }
 
  Future<void> _onGetCurrentLocation(
    GetCurrentLocationEvent event,
    Emitter<LocationSelectionState> emit,
  ) async {
    emit(LocationSelectionLoading());
 
    try {
      bool serviceEnabled = await Geolocator.isLocationServiceEnabled();
      if (!serviceEnabled) {
        emit(const LocationSelectionError(
          message: 'Location services are disabled',
        ));
        return;
      }
 
      LocationPermission permission = await Geolocator.checkPermission();
      if (permission == LocationPermission.denied) {
        permission = await Geolocator.requestPermission();
        if (permission == LocationPermission.denied) {
          emit(const LocationSelectionError(
            message: 'Location permissions are denied',
          ));
          return;
        }
      }
 
      if (permission == LocationPermission.deniedForever) {
        emit(const LocationSelectionError(
          message: 'Location permissions are permanently denied',
        ));
        return;
      }
 
      final position = await Geolocator.getCurrentPosition(
        locationSettings: const LocationSettings(
          accuracy: LocationAccuracy.high,
          timeLimit: Duration(seconds: 10),
        ),
      );
 
      final location = LatLng(position.latitude, position.longitude);
      
      emit(LocationSelectionSuccess(
        location: location,
        address: 'Getting your location...',
        isAddressLoading: true,
      ));
 
      // Get address for the location
      add(GetAddressFromLocationEvent(location: location));
    } catch (e) {
      emit(const LocationSelectionError(
        message: 'Unable to get current location',
      ));
    }
  }
 
  Future<void> _onUpdateLocation(
    UpdateLocationEvent event,
    Emitter<LocationSelectionState> emit,
  ) async {
    emit(LocationSelectionSuccess(
      location: event.location,
      address: 'Getting address...',
      isAddressLoading: true,
    ));
 
    // Get address for the new location
    add(GetAddressFromLocationEvent(location: event.location));
  }
 
  Future<void> _onGetAddressFromLocation(
    GetAddressFromLocationEvent event,
    Emitter<LocationSelectionState> emit,
  ) async {
    try {
      List<Placemark> placemarks = await placemarkFromCoordinates(
        event.location.latitude,
        event.location.longitude,
      );
 
      if (placemarks.isNotEmpty) {
        final placemark = placemarks.first;
        String address = '';
 
        if (placemark.street != null && placemark.street!.isNotEmpty) {
          address += placemark.street!;
        }
 
        if (placemark.locality != null && placemark.locality!.isNotEmpty) {
          if (address.isNotEmpty) address += ', ';
          address += placemark.locality!;
        }
 
        if (placemark.administrativeArea != null &&
            placemark.administrativeArea!.isNotEmpty) {
          if (address.isNotEmpty) address += ', ';
          address += placemark.administrativeArea!;
        }
 
        if (placemark.country != null && placemark.country!.isNotEmpty) {
          if (address.isNotEmpty) address += ', ';
          address += placemark.country!;
        }
 
        emit(LocationSelectionSuccess(
          location: event.location,
          address: address.isNotEmpty ? address : 'Selected Location',
          isAddressLoading: false,
        ));
      } else {
        emit(LocationSelectionSuccess(
          location: event.location,
          address: 'Selected Location',
          isAddressLoading: false,
        ));
      }
    } catch (e) {
      emit(LocationSelectionSuccess(
        location: event.location,
        address: 'Selected Location',
        isAddressLoading: false,
      ));
    }
  }
 
  Future<void> _onSelectSavedLocation(
    SelectSavedLocationEvent event,
    Emitter<LocationSelectionState> emit,
  ) async {
    emit(LocationSelectionSuccess(
      location: event.location,
      address: event.address,
      isAddressLoading: false,
    ));
  }
 
  Future<void> _onConfirmLocation(
    ConfirmLocationEvent event,
    Emitter<LocationSelectionState> emit,
  ) async {
    final currentState = state;
    if (currentState is LocationSelectionSuccess) {
      emit(LocationConfirmed(
        location: currentState.location,
        address: currentState.address.isNotEmpty 
            ? currentState.address 
            : 'Location (${currentState.location.latitude.toStringAsFixed(4)}, ${currentState.location.longitude.toStringAsFixed(4)})',
      ));
    }
  }
 
  Future<void> _onResetLocationSelection(
    ResetLocationSelectionEvent event,
    Emitter<LocationSelectionState> emit,
  ) async {
    emit(LocationSelectionInitial());
  }
}