Accediendo a Características de get_it

Esta guía muestra cómo acceder a características de get_it desde dentro de widgets watch_it. Para explicaciones detalladas de cada característica de get_it, ver la documentación de get_it.

Scopes con pushScope

Los scopes de get_it crean registros temporales que se limpian automáticamente. Perfecto para estado específico de pantalla. Ver Scopes de get_it para detalles.

pushScope() - Gestión Automática de Scope

pushScope() crea un scope cuando el widget se monta y lo limpia automáticamente al disponerse:

class UserProfileScreen extends WatchingWidget {
  @override
  Widget build(BuildContext context) {
    // Create scope on first build
    pushScope(
      init: (getIt) {
        // Register screen-specific dependencies
        getIt.registerLazySingleton<ProfileManager>(
          () => ProfileManager(userId: '123'),
        );
      },
      dispose: () {
        // Optional cleanUp when the scope is popped when the widget gets disposed
        print('Profile screen scope disposed');
      },
    );

    // Use scoped dependencies
    final profile = watchValue((ProfileManager m) => m.profile);

    return YourUI();
  }
}

Qué sucede:

1. El widget se construye por primera vez → Se empuja el scope, se ejecuta el callback init
2. Las dependencias se registran en el nuevo scope
3. El widget puede observar dependencias del scope
4. El widget se dispone → El scope se saca automáticamente, se ejecuta el callback dispose

Caso de Uso: Estado Específico de Pantalla

class ProductDetailScreen extends WatchingWidget {
  final String productId;

  ProductDetailScreen({required this.productId});

  @override
  Widget build(BuildContext context) {
    pushScope(
      init: (getIt) {
        // Register screen-specific manager
        getIt.registerLazySingleton<ProductDetailManager>(
          () => ProductDetailManager(productId: productId),
        );
      },
    );

    final product = watchValue((ProductDetailManager m) => m.product);
    final isLoading = watchValue((ProductDetailManager m) => m.isLoading);

    if (isLoading) return CircularProgressIndicator();
    return ProductDetailView(product: product);
  }
}

Instancias con Nombre

Observa instancias con nombre específicas desde get_it. Ver Instancias con Nombre de get_it para detalles de registro.

Observar Instancias con Nombre

class ApiMonitor extends WatchingWidget {
  @override
  Widget build(BuildContext context) {
    // Watch specific named instances
    final prodApi = watchValue(
      (ApiClientExtended api) => api.requestCount,
      instanceName: 'production',
    );

    final stagingApi = watchValue(
      (ApiClientExtended api) => api.requestCount,
      instanceName: 'staging',
    );

    return Column(
      children: [
        Text('Production: $prodApi requests'),
        Text('Staging: $stagingApi requests'),
      ],
    );
  }
}

Casos de uso:

• Múltiples configuraciones (dev/prod)
• Feature flags
• Variantes de A/B testing

Inicialización Async

Maneja inicialización compleja donde las dependencias async deben estar listas antes de que la app inicie. Ver Objetos Async de get_it para detalles de registro.

isReady - Dependencia Individual

Verifica si una dependencia async específica está lista:

void setupDependenciesAsync() async {
  // Register async singleton
  di.registerSingletonAsync<Database>(
    () async {
      final db = Database();
      await db.initialize();
      return db;
    },
  );
}

class App extends WatchingWidget {
  @override
  Widget build(BuildContext context) {
    // Check if ready
    final ready = isReady<Database>();

    if (!ready) {
      return SplashScreen();
    }

    return MainApp();
  }
}

allReady - Múltiples Dependencias

Espera a que todas las dependencias async se completen:

void setupMultipleDependencies() async {
  di.registerSingletonAsync<Database>(() async {
    final db = Database();
    await db.initialize();
    return db;
  });

  di.registerSingletonAsync<ConfigService>(() async {
    final config = ConfigService();
    await config.loadFromFile();
    return config;
  });

  di.registerSingletonAsync<AuthServiceAdvanced>(
    () async {
      final auth = AuthServiceAdvanced();
      await auth.initialize();
      return auth;
    },
    dependsOn: [Database], // Waits for Database first
  );
}

class AppAllReady extends WatchingWidget {
  @override
  Widget build(BuildContext context) {
    // Wait for all async singletons
    final ready = allReady(
      timeout: Duration(seconds: 30),
    );

    if (!ready) {
      return Scaffold(
        body: Center(
          child: CircularProgressIndicator(),
        ),
      );
    }

    return MainApp();
  }
}

Observar Progreso de Inicialización

class InitializationScreen extends WatchingWidget {
  @override
  Widget build(BuildContext context) {
    final dbReady = isReady<Database>();
    final configReady = isReady<ConfigService>();
    final authReady = isReady<AuthServiceAdvanced>();

    final progress =
        [dbReady, configReady, authReady].where((ready) => ready).length / 3;

    if (dbReady && configReady && authReady) {
      // All ready, navigate to main app
      callOnceAfterThisBuild((context) {
        Navigator.of(context).pushReplacement(
          MaterialPageRoute(builder: (_) => MainApp()),
        );
      });
    }

    return Column(
      children: [
        LinearProgressIndicator(value: progress),
        Text('Initializing... ${(progress * 100).toInt()}%'),
        if (dbReady) Text('✓ Database ready'),
        if (configReady) Text('✓ Configuration loaded'),
        if (authReady) Text('✓ Authentication ready'),
      ],
    );
  }
}

Ver También

• Documentación de Scopes de get_it
• Objetos Async de get_it
• Instancias con Nombre de get_it
• Best Practices