location_search_bar.dart

Go to the documentation of this file.

import 'package:easy_localization/easy_localization.dart';
import 'package:flutter/material.dart';
import 'package:flutter_screenutil/flutter_screenutil.dart';
import 'package:fluentui_system_icons/fluentui_system_icons.dart';
import 'package:google_maps_flutter/google_maps_flutter.dart';
import 'package:geocoding/geocoding.dart';
import 'dart:async';
 
import '../../../../../../core/ui/theme/color_palette.dart';
import '../models/search_result.dart';
 
class LocationSearchBar extends StatefulWidget {
  final TextEditingController controller;
  final Function(LatLng) onLocationSelected;
  final bool isVisible;
  final VoidCallback? onClose;
 
  const LocationSearchBar({
    super.key,
    required this.controller,
    required this.onLocationSelected,
    this.isVisible = true,
    this.onClose,
  });
 
  @override
  State<LocationSearchBar> createState() => _LocationSearchBarState();
}
 
class _LocationSearchBarState extends State<LocationSearchBar> {
  bool _isSearching = false;
  List<SearchResult> _searchResults = [];
  final FocusNode _focusNode = FocusNode();
  Timer? _debounceTimer;
 
  bool _isSearchError = false;
 
  void _onSearchChanged(String query) {
    // Cancel previous timer
    _debounceTimer?.cancel();
    
    if (query.isEmpty) {
      setState(() {
        _isSearching = false;
        _searchResults = [];
        _isSearchError = false;
      });
      return;
    }
 
    // Set new timer to debounce the search
    _debounceTimer = Timer(const Duration(milliseconds: 500), () {
      _performGeocodingSearch(query);
    });
  }
 
  Future<void> _performGeocodingSearch(String query) async {
    setState(() {
      _isSearching = true;
      _isSearchError = false;
    });
 
    try {
      // Use geocoding package to search for locations
      List<Location> locations = await locationFromAddress(query);
      
      List<SearchResult> results = [];
      
      // Convert Location objects to SearchResult objects
      for (int i = 0; i < locations.length && i < 5; i++) {
        final location = locations[i];
        
        try {
          // Get detailed address information for each location
          List<Placemark> placemarks = await placemarkFromCoordinates(
            location.latitude,
            location.longitude,
          );
          
          if (placemarks.isNotEmpty) {
            final placemark = placemarks.first;
            
            String name = query;
            String address = _buildAddressString(placemark);
            
            // If we have a more specific name from the placemark, use it
            if (placemark.name != null && placemark.name!.isNotEmpty) {
              name = placemark.name!;
            } else if (placemark.thoroughfare != null && placemark.thoroughfare!.isNotEmpty) {
              name = placemark.thoroughfare!;
            }
            
            results.add(SearchResult(
              name: name,
              address: address,
              latLng: LatLng(location.latitude, location.longitude),
            ));
          }
        } catch (e) {
          // If reverse geocoding fails for this location, add it with basic info
          results.add(SearchResult(
            name: query,
            address: '${location.latitude.toStringAsFixed(4)}, ${location.longitude.toStringAsFixed(4)}',
            latLng: LatLng(location.latitude, location.longitude),
          ));
        }
      }
      
      if (mounted) {
        setState(() {
          _searchResults = results;
          _isSearching = false;
          _isSearchError = results.isEmpty;
        });
      }
    } catch (e) {
      if (mounted) {
        setState(() {
          _searchResults = [];
          _isSearching = false;
          _isSearchError = true;
        });
      }
    }
  }
 
  String _buildAddressString(Placemark placemark) {
    List<String> addressParts = [];
    
    if (placemark.thoroughfare != null && placemark.thoroughfare!.isNotEmpty) {
      addressParts.add(placemark.thoroughfare!);
    }
    if (placemark.locality != null && placemark.locality!.isNotEmpty) {
      addressParts.add(placemark.locality!);
    }
    if (placemark.administrativeArea != null && placemark.administrativeArea!.isNotEmpty) {
      addressParts.add(placemark.administrativeArea!);
    }
    if (placemark.country != null && placemark.country!.isNotEmpty) {
      addressParts.add(placemark.country!);
    }
    
    return addressParts.isNotEmpty ? addressParts.join(', ') : 'Location';
  }
 
  void _onResultSelected(SearchResult result) {
    widget.controller.text = result.name;
    widget.onLocationSelected(result.latLng);
    setState(() {
      _isSearching = false;
      _searchResults = [];
    });
    _focusNode.unfocus();
  }
 
  void _clearSearch() {
    widget.controller.clear();
    setState(() {
      _isSearching = false;
      _searchResults = [];
    });
    _focusNode.unfocus();
  }
 
  void _closeSearch() {
    _clearSearch();
    if (widget.onClose != null) {
      widget.onClose!();
    }
  }
 
  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Container(
          decoration: BoxDecoration(
            color: Colors.white,
            borderRadius: BorderRadius.circular(12.r),
            boxShadow: [
              BoxShadow(
                color: Colors.black.withValues(alpha: 0.1),
                blurRadius: 8,
                offset: const Offset(0, 2),
              ),
            ],
          ),
          child: Row(
            children: [
              Expanded(
                child: TextField(
                  controller: widget.controller,
                  focusNode: _focusNode,
                  onChanged: _onSearchChanged,
                  autofocus: true,
                  decoration: InputDecoration(
                    hintText: 'scheduling.search_for_location'.tr(),
                    hintStyle: TextStyle(
                      color: Colors.grey[500],
                      fontSize: 14.sp,
                    ),
                    prefixIcon: Icon(
                      FluentIcons.search_16_regular,
                      color: Colors.grey[500],
                      size: 17.sp,
                    ),
                    border: InputBorder.none,
                    contentPadding: EdgeInsets.symmetric(
                      horizontal: 16.w,
                      vertical: 16.h,
                    ),
                  ),
                  style: TextStyle(
                    fontSize: 14.sp,
                    color: Colors.black87,
                  ),
                ),
              ),
              IconButton(
                icon: Icon(
                  FluentIcons.dismiss_16_filled,
                  color: Colors.grey[600],
                  size: 17.sp,
                ),
                onPressed: _closeSearch,
              ),
            ],
          ),
        ),
        if (_isSearching || _searchResults.isNotEmpty || _isSearchError)
          Container(
            margin: EdgeInsets.only(top: 8.h),
            decoration: BoxDecoration(
              color: Colors.white,
              borderRadius: BorderRadius.circular(12.r),
              boxShadow: [
                BoxShadow(
                  color: Colors.black.withValues(alpha: 0.1),
                  blurRadius: 8,
                  offset: const Offset(0, 2),
                ),
              ],
            ),
            child: _buildSearchContent(),
          ),
      ],
    );
  }
 
  Widget _buildSearchContent() {
    if (_isSearching) {
      return Padding(
        padding: EdgeInsets.all(16.w),
        child: Row(
          children: [
            SizedBox(
              width: 20.w,
              height: 20.h,
              child: CircularProgressIndicator(
                strokeWidth: 2,
                valueColor: AlwaysStoppedAnimation<Color>(ColorPalette.lightGreen),
              ),
            ),
            SizedBox(width: 12.w),
            Text(
              'scheduling.searching'.tr(),
              style: TextStyle(
                fontSize: 14.sp,
                color: Colors.grey[600],
              ),
            ),
          ],
        ),
      );
    }
 
    if (_isSearchError) {
      return Padding(
        padding: EdgeInsets.all(16.w),
        child: Row(
          children: [
            Icon(
              FluentIcons.error_circle_16_filled,
              color: Colors.red[400],
              size: 17.sp,
            ),
            SizedBox(width: 12.w),
            Expanded(
              child: Text(
                'scheduling.no_locations_found'.tr(),
                style: TextStyle(
                  fontSize: 14.sp,
                  color: Colors.grey[600],
                ),
              ),
            ),
          ],
        ),
      );
    }
 
    if (_searchResults.isNotEmpty) {
      return ListView.separated(
        shrinkWrap: true,
        physics: const NeverScrollableScrollPhysics(),
        itemCount: _searchResults.length,
        separatorBuilder: (context, index) => Divider(
          height: 1,
          color: Colors.grey[200],
        ),
        itemBuilder: (context, index) {
          final result = _searchResults[index];
          return ListTile(
            leading: Icon(
              FluentIcons.location_16_filled,
              color: ColorPalette.lightGreen,
              size: 17.sp,
            ),
            title: Text(
              result.name,
              style: TextStyle(
                fontSize: 14.sp,
                fontWeight: FontWeight.w500,
                color: Colors.black87,
              ),
            ),
            subtitle: Text(
              result.address,
              style: TextStyle(
                fontSize: 13.sp,
                color: Colors.grey[600],
              ),
            ),
            onTap: () => _onResultSelected(result),
          );
        },
      );
    }
 
    return const SizedBox.shrink();
  }
 
  @override
  void dispose() {
    _focusNode.dispose();
    _debounceTimer?.cancel();
    super.dispose();
  }
}