phinx_provider_package 0.1.3

A Flutter package for managing state using Provider with singleton access and service state management.

phinx_provider_package

phinx_provider_package es un paquete de Flutter que proporciona herramientas útiles para gestionar el estado en aplicaciones utilizando Provider. Este paquete incluye clases para manejar singletons, proveedores de servicios, y proveedores de servicios múltiples, permitiendo una gestión eficiente y organizada del estado de la aplicación.

Features

• ServiceProvider: Un wrapper alrededor de ChangeNotifier para gestionar el estado de un servicio en particular, manejando diferentes estados como idle, working, success, error, y exception.
• MultiServiceProvider: Extiende ChangeNotifier para manejar el estado de múltiples servicios, proporcionando utilidades para gestionar estos estados de manera independiente.
• LinkedProviderManager: Permite registrar y obtener instancias de proveedores de forma centralizada, independiente del contexto.
• LinkedProvider: Proveedor que extiende ListenableProvider y permite la vinculación automática con LinkedProviders.
• LinkedProviders: Widget para gestionar múltiples proveedores y registrar automáticamente los LinkedProviders.
• LinkedWidget: Widget abstracto que facilita la vinculación de widgets con los proveedores registrados en LinkedProviderManager.

Getting started

Para comenzar a usar el paquete, agrégalo a tu archivo pubspec.yaml:

En la sección dependencies, añade el siguiente código:

dependencies:
  flutter:
    sdk: flutter
  phinx_provider_package: 0.1.3

Usage

ServiceProvider

ServiceProvider es una clase abstracta que extiende ChangeNotifier para manejar el estado de un servicio. Puedes utilizarla para gestionar estados como idle, working, success, error, y exception de manera centralizada.

Ejemplo básico

En este ejemplo, MyServiceProvider extiende ServiceProvider para manejar un servicio que actualiza un valor.

import 'package:phinx_provider_package/provider/service_provider.dart';

class MyServiceProvider extends ServiceProvider<int> {
  MyServiceProvider() : super(data: 0);

  Future<void> updateData() async {
    await baseCall(() async {
      // Simula una llamada a un servicio
      await Future.delayed(Duration(seconds: 1));
      data = data + 1;
    });
  }
}

void main() {
  MyServiceProvider provider = MyServiceProvider();

  provider.updateData().then((_) {
    print(provider.data); // Imprime "1"
  });
}

MultiServiceProvider

MultiServiceProvider extiende ChangeNotifier y permite manejar el estado de múltiples servicios bajo un mismo proveedor. Esto es útil cuando tienes varias fuentes de datos o servicios relacionados que necesitan ser gestionados en conjunto.

Ejemplo básico

Supongamos que tienes dos servicios diferentes, ServiceA y ServiceB, y deseas gestionar sus estados simultáneamente en un mismo proveedor. Puedes utilizar un switch dentro del método baseCall para manejar las diferentes operaciones en función del servicio.

import 'package:phinx_provider_package/provider/multi_service_provider.dart';

class MyMultiServiceProvider extends MultiServiceProvider<Map<String, int>> {
  MyMultiServiceProvider() : super(data: {});

  Future<void> fetchData(String serviceKey) async {
    await baseCall(serviceKey, () async {
      switch (serviceKey) {
        case 'serviceA':
          // Simula la llamada al servicio A
          await Future.delayed(Duration(seconds: 1));
          data['serviceA'] = (data['serviceA'] ?? 0) + 1;
          break;
        case 'serviceB':
          // Simula la llamada al servicio B
          await Future.delayed(Duration(seconds: 1));
          data['serviceB'] = (data['serviceB'] ?? 0) + 1;
          break;
        default:
          throw Exception('Unknown service key: $serviceKey');
      }
    });
  }
}

void main() {
  MyMultiServiceProvider provider = MyMultiServiceProvider();

  provider.fetchData('serviceA').then((_) {
    print(provider.data['serviceA']); // Imprime "1"
  });

  provider.fetchData('serviceB').then((_) {
    print(provider.data['serviceB']); // Imprime "1"
  });
}

LinkedProviderManager

LinkedProviderManager te permite registrar y obtener proveedores de forma centralizada, sin necesidad de tener acceso directo al contexto de Flutter.

Ejemplo básico

Supongamos que tienes un proveedor llamado CounterProvider que maneja el conteo de un número. Aquí te mostramos cómo registrar y obtener este proveedor utilizando LinkedProviderManager.

import 'package:phinx_provider_package/provider/linked_provider_manager.dart';

class CounterProvider extends ChangeNotifier {
  int _count = 0;

  int get count => _count;

  void increment() {
    _count++;
    notifyListeners();
  }
}

void main() {
  LinkedProviderManager().register(CounterProvider(), name: "counterProvider");

  CounterProvider provider = LinkedProviderManager().get<CounterProvider>(name: "counterProvider");
  provider.increment();
  print(provider.count); // Imprime "1"
}

LinkedProvider

LinkedProvider es una extensión de ListenableProvider que permite la vinculación automática de proveedores con LinkedProviders, haciendo que los proveedores sean accesibles desde cualquier parte de la aplicación.

Ejemplo básico

En este ejemplo, CounterProvider es un proveedor que maneja un contador. Se utiliza LinkedProvider para registrar este proveedor en la jerarquía de widgets.

import 'package:flutter/material.dart';
import 'package:phinx_provider_package/provider/linked_provider.dart';
import 'package:phinx_provider_package/widget/linked_providers.dart';

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

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

  @override
  Widget build(BuildContext context) {
    return const MaterialApp(
      home: HomeScreen(),
    );
  }
}

class CounterProvider extends ChangeNotifier {
  int _count = 0;

  int get count => _count;

  void increment() {
    _count++;
    notifyListeners();
  }
}

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

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('LinkedProvider Example'),
      ),
      body: LinkedProviders(
        providers: [
          LinkedProvider(
            create: (_) => CounterProvider(),
          ),
        ],
        child: const Body(),
      ),
    );
  }
}

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

  @override
  Widget build(BuildContext context) {
    final provider = Provider.of<CounterProvider>(context);

    return Center(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: <Widget>[
          Text(
            'Counter: ${provider.count}',
            style: const TextStyle(fontSize: 24),
          ),
          const SizedBox(height: 20),
          ElevatedButton(
            child: const Text('Increment Counter'),
            onPressed: () => provider.increment(),
          ),
        ],
      ),
    );
  }
}

LinkedProviders

LinkedProviders es un widget que actúa como un contenedor para múltiples proveedores, registrando automáticamente los LinkedProviders en el LinkedProviderManager.

Ejemplo básico

Aquí utilizamos LinkedProviders para gestionar múltiples proveedores, CounterProvider y OtherProvider, dentro de la misma jerarquía de widgets.

import 'package:flutter/material.dart';
import 'package:phinx_provider_package/provider/linked_provider.dart';
import 'package:phinx_provider_package/widget/linked_providers.dart';

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

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

  @override
  Widget build(BuildContext context) {
    return const MaterialApp(
      home: HomeScreen(),
    );
  }
}

class CounterProvider extends ChangeNotifier {
  int _count = 0;

  int get count => _count;

  void increment() {
    _count++;
    notifyListeners();
  }
}

class OtherProvider extends ChangeNotifier {
  int _count = 0;

  int get count => _count;

  void increment() {
    _count++;
    notifyListeners();
  }
}

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

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Modal & Counter Example'),
      ),
      body: LinkedProviders(
        providers: [
          LinkedProvider(
            create: (_) => OtherProvider(),
            name: "counter",
          ),
          LinkedProvider(
            create: (_) => CounterProvider(),
          )
        ],
        child: const Body(),
      ),
    );
  }
}

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

  @override
  Widget build(BuildContext context) {
    final provider = Provider.of<CounterProvider>(context);

    return Center(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: <Widget>[
          ElevatedButton(
            child: const Text('Show Modal'),
            onPressed: () => showModal(context),
          ),
          const SizedBox(height: 20),
          Text(
            'Counter: ${provider.count}',
            style: const TextStyle(fontSize: 24),
          ),
          const SizedBox(height: 20),
          ElevatedButton(
            child: const Text('Increment Counter'),
            onPressed: () => provider.increment(),
          ),
          const InSameTree(),
        ],
      ),
    );
  }

  void showModal(BuildContext context) {
    showDialog(
      context: context,
      builder: (BuildContext context) {
        return const Alerta();
      },
    );
  }
}

LinkedWidget

LinkedWidget es un widget abstracto que facilita la vinculación de widgets con los proveedores registrados en LinkedProviderManager.

Ejemplo básico

En este ejemplo, Alerta y InSameTree son widgets que utilizan LinkedWidget para acceder a un proveedor registrado en LinkedProviderManager. Esto es útil para gestionar la lógica del proveedor en widgets que pueden estar en diferentes partes de la jerarquía de widgets.

import 'package:flutter/material.dart';
import 'package:phinx_provider_package/widget/linked_widget.dart';
import 'package:phinx_provider_package/provider/linked_provider.dart';

class Alerta extends LinkedWidget {
  const Alerta({
    super.key,
  });

  @override
  Widget build(BuildContext context, Linked linked) {
    final provider = linked.get<CounterProvider>();

    return AlertDialog(
      title: const Text('Modal Title'),
      content: Text('This is the content of the modal. ${provider.count}'),
      actions: <Widget>[
        TextButton(
          child: const Text('Increment'),
          onPressed: () {
            provider.increment();


          },
        ),
        TextButton(
          child: const Text('Close'),
          onPressed: () {
            Navigator.of(context).pop();
          },
        ),
      ],
    );
  }
}

class InSameTree extends LinkedWidget {
  const InSameTree({super.key});

  @override
  Widget build(BuildContext context, Linked linked) {
    final provider = linked.get<CounterProvider>();
    return Column(
      children: [
        const Text("In the same tree using LinkedWidget"),
        Text(provider.count.toString()),
      ],
    );
  }
}

Información Adicional

Publicar el paquete en pub.dev

1. Preparar para la publicación:

   • Actualiza la versión en pubspec.yaml.
   • Asegúrate de que la descripción, el README, y la documentación estén al día.
   • Verifica que todas las dependencias estén correctamente configuradas.
   • Ejecuta flutter pub publish --dry-run para comprobar que todo esté listo.

2. Actualizar CHANGELOG.md:

   • Añade las notas de la nueva versión al changelog.

3. Probar localmente:

   • Prueba el paquete en un proyecto local para asegurarte de que funciona correctamente.

4. Gestionar etiquetas en Git (opcional pero recomendado):

   • Crea una etiqueta para la nueva versión en Git:

     git tag -a vX.X.X -m "Release version X.X.X"
     

   • Empuja la etiqueta al repositorio remoto:

     git push
     git push origin --tags
     

5. Publicar el paquete:

   • Ejecuta flutter pub publish para publicar la nueva versión.
   • Sigue las instrucciones que aparecen durante el proceso de publicación.