flutter_mobile_red_type 0.0.1

flutter_mobile_red_type: ^0.0.1 copied to clipboard

example/lib/main.dart

import 'package:flutter/material.dart';
import 'package:flutter_mobile_red_type/flutter_mobile_red_type.dart';
import 'package:permission_handler/permission_handler.dart';
import 'dart:developer' as developer;

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Mobile Red Type Example',
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: Colors.blue),
        useMaterial3: true,
      ),
      home: const NetworkTypeScreen(),
    );
  }
}

class NetworkTypeScreen extends StatefulWidget {
  const NetworkTypeScreen({super.key});

  @override
  State<NetworkTypeScreen> createState() => _NetworkTypeScreenState();
}

class _NetworkTypeScreenState extends State<NetworkTypeScreen> {
  NetworkType? _networkType;
  bool _isLoading = false;
  String? _errorMessage;

  Future<void> _requestPermissions() async {
    developer.log('🔐 Requesting phone permissions...', name: 'NetworkType');

    final status = await Permission.phone.request();
    developer.log(
      '📱 Permission status after request: ${status.toString()}',
      name: 'NetworkType',
    );
    developer.log(
      '✅ Permission granted? ${status.isGranted}',
      name: 'NetworkType',
    );
    developer.log(
      '❌ Permission denied? ${status.isDenied}',
      name: 'NetworkType',
    );
    developer.log(
      '🚫 Permission permanently denied? ${status.isPermanentlyDenied}',
      name: 'NetworkType',
    );

    if (status.isGranted) {
      developer.log(
        '✅ Permission granted, checking network type...',
        name: 'NetworkType',
      );
      await _checkNetworkType();
    } else {
      developer.log(
        '❌ Permission not granted. Status: $status',
        name: 'NetworkType',
      );
      setState(() {
        _networkType = NetworkType.permissionDenied;
        _isLoading = false;
        _errorMessage = 'Permission status: $status';
      });
    }
  }

  Future<void> _checkNetworkType() async {
    developer.log(
      '🔍 Starting network type verification...',
      name: 'NetworkType',
    );

    setState(() {
      _isLoading = true;
      _errorMessage = null;
    });

    try {
      // Check if we have permissions
      final phoneStatus = await Permission.phone.status;
      developer.log(
        '📱 Current permission status: ${phoneStatus.toString()}',
        name: 'NetworkType',
      );
      developer.log(
        '✅ Permission granted? ${phoneStatus.isGranted}',
        name: 'NetworkType',
      );

      if (!phoneStatus.isGranted) {
        developer.log(
          '❌ Permission not granted, cannot verify network type',
          name: 'NetworkType',
        );
        setState(() {
          _networkType = NetworkType.permissionDenied;
          _isLoading = false;
          _errorMessage = 'Permission denied. Status: $phoneStatus';
        });
        return;
      }

      developer.log(
        '📡 Calling plugin to get network type...',
        name: 'NetworkType',
      );
      final networkType = await FlutterMobileRedType.getNetworkType();
      developer.log(
        '📡 Network type obtained: ${networkType.value}',
        name: 'NetworkType',
      );

      setState(() {
        _networkType = networkType;
        _isLoading = false;
      });

      if (networkType == NetworkType.permissionDenied) {
        developer.log(
          '⚠️ Plugin returned PERMISSION_DENIED even though permission is granted',
          name: 'NetworkType',
        );
        setState(() {
          _errorMessage =
              'Plugin indicates permission denied. Check native logs.';
        });
      }
    } catch (e, stackTrace) {
      developer.log('❌ Error verifying network type: $e', name: 'NetworkType');
      developer.log('📚 Stack trace: $stackTrace', name: 'NetworkType');
      setState(() {
        _errorMessage = 'Error: $e';
        _isLoading = false;
      });
    }
  }

  Color _getNetworkTypeColor(NetworkType? networkType) {
    switch (networkType) {
      case NetworkType.twoG:
        return Colors.red;
      case NetworkType.threeG:
        return Colors.orange;
      case NetworkType.fourG:
        return Colors.blue;
      case NetworkType.fiveG:
        return Colors.green;
      case NetworkType.permissionDenied:
        return Colors.red.shade700;
      case NetworkType.unknown:
      case null:
        return Colors.grey;
    }
  }

  String _getNetworkTypeDescription(NetworkType? networkType) {
    switch (networkType) {
      case NetworkType.twoG:
        return '2G Network (GPRS, EDGE)\nSlow data speed';
      case NetworkType.threeG:
        return '3G Network (UMTS, HSPA)\nModerate data speed';
      case NetworkType.fourG:
        return '4G Network (LTE)\nFast data speed';
      case NetworkType.fiveG:
        return '5G Network (NR)\nVery fast data speed';
      case NetworkType.permissionDenied:
        return 'Permissions denied\nGrant the necessary permissions to access network state';
      case NetworkType.unknown:
        return 'Unknown network type\nCould not determine connection type';
      case null:
        return 'Press the button to verify network type';
    }
  }

  IconData _getNetworkTypeIcon(NetworkType? networkType) {
    switch (networkType) {
      case NetworkType.twoG:
      case NetworkType.threeG:
      case NetworkType.fourG:
      case NetworkType.fiveG:
        return Icons.signal_cellular_alt;
      case NetworkType.permissionDenied:
        return Icons.block;
      case NetworkType.unknown:
      case null:
        return Icons.signal_cellular_off;
    }
  }

  @override
  void initState() {
    super.initState();
    // Check permissions and network type on startup
    WidgetsBinding.instance.addPostFrameCallback((_) async {
      developer.log('🚀 Initializing screen...', name: 'NetworkType');
      final phoneStatus = await Permission.phone.status;
      developer.log(
        '📱 Initial permission status: ${phoneStatus.toString()}',
        name: 'NetworkType',
      );

      if (phoneStatus.isGranted) {
        developer.log(
          '✅ Permission already granted, checking network type...',
          name: 'NetworkType',
        );
        _checkNetworkType();
      } else {
        developer.log(
          '🔐 Permission not granted, requesting permissions...',
          name: 'NetworkType',
        );
        // Request permissions automatically on startup
        _requestPermissions();
      }
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Mobile Network Type'),
        backgroundColor: Theme.of(context).colorScheme.inversePrimary,
      ),
      body: Center(
        child: Padding(
          padding: const EdgeInsets.all(24.0),
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              // Large network type icon
              Container(
                width: 150,
                height: 150,
                decoration: BoxDecoration(
                  shape: BoxShape.circle,
                  color: _getNetworkTypeColor(_networkType).withOpacity(0.1),
                  border: Border.all(
                    color: _getNetworkTypeColor(_networkType),
                    width: 4,
                  ),
                ),
                child: Icon(
                  _getNetworkTypeIcon(_networkType),
                  size: 80,
                  color: _getNetworkTypeColor(_networkType),
                ),
              ),
              const SizedBox(height: 32),

              // Network type
              if (_networkType != null)
                Text(
                  _networkType!.value,
                  style: TextStyle(
                    fontSize: 48,
                    fontWeight: FontWeight.bold,
                    color: _getNetworkTypeColor(_networkType),
                  ),
                ),

              const SizedBox(height: 16),

              // Description
              Text(
                _getNetworkTypeDescription(_networkType),
                textAlign: TextAlign.center,
                style: TextStyle(fontSize: 16, color: Colors.grey[700]),
              ),

              if (_errorMessage != null) ...[
                const SizedBox(height: 24),
                Container(
                  padding: const EdgeInsets.all(12),
                  decoration: BoxDecoration(
                    color: Colors.red.shade50,
                    borderRadius: BorderRadius.circular(8),
                    border: Border.all(color: Colors.red.shade300),
                  ),
                  child: Row(
                    mainAxisSize: MainAxisSize.min,
                    children: [
                      Icon(Icons.error_outline, color: Colors.red.shade700),
                      const SizedBox(width: 8),
                      Text(
                        _errorMessage!,
                        style: TextStyle(color: Colors.red.shade700),
                      ),
                    ],
                  ),
                ),
              ],

              const SizedBox(height: 48),

              // Button to request permissions if denied
              if (_networkType == NetworkType.permissionDenied) ...[
                FilledButton.icon(
                  onPressed: _isLoading ? null : _requestPermissions,
                  icon: const Icon(Icons.lock_open),
                  label: const Text('Request permissions'),
                  style: FilledButton.styleFrom(
                    padding: const EdgeInsets.symmetric(
                      horizontal: 32,
                      vertical: 16,
                    ),
                    backgroundColor: Colors.orange,
                  ),
                ),
                const SizedBox(height: 16),
              ],

              // Button to verify
              FilledButton.icon(
                onPressed: _isLoading ? null : _checkNetworkType,
                icon: _isLoading
                    ? const SizedBox(
                        width: 20,
                        height: 20,
                        child: CircularProgressIndicator(
                          strokeWidth: 2,
                          valueColor: AlwaysStoppedAnimation<Color>(
                            Colors.white,
                          ),
                        ),
                      )
                    : const Icon(Icons.refresh),
                label: Text(_isLoading ? 'Checking...' : 'Check network type'),
                style: FilledButton.styleFrom(
                  padding: const EdgeInsets.symmetric(
                    horizontal: 32,
                    vertical: 16,
                  ),
                ),
              ),

              const SizedBox(height: 24),

              // Additional information
              Text(
                'Only works on Android devices with active mobile connection',
                textAlign: TextAlign.center,
                style: TextStyle(
                  fontSize: 12,
                  color: Colors.grey[500],
                  fontStyle: FontStyle.italic,
                ),
              ),
            ],
          ),
        ),
      ),
    );
  }
}