flutter_cpnetworking_service

Description:

flutter cpnetworking service

flutter_cpnetworking_service #
A netowrking wrapper which using dio and flutter_secure_storage(ios, android)/shared_preferences(web) to handle storage token or sensitive data in general, and use token as authorization info when requesting to http connection.
Usage #
We’re going to use random news API which generates news data and returns it in JSON format.
Basic news model
class NewsEnity implements BaseModelInterface {
final String title;
  final String id;
final String description;
  final List<String> categories;
  final List<String> medias;
  final int published;
  String formattedPublished(String languageCode) {
    var date = DateTime.fromMillisecondsSinceEpoch(published);
    var formattedDate = DateFormat.yMMMMd(languageCode).format(date);
    return formattedDate;
  }
  NewsEnity(
      {@required this.title,
      @required this.id,
      @required this.description,
      @required this.medias,
      @required this.categories,
      @required this.published});
  factory NewsEnity.fromJson(Map<String, dynamic> json) {
    List<String> category;
    if (json['category'] is String) {
      category = [json['category'].toString()];
    }
    return NewsEnity(
        title: json['title'],
        id: json['id'],
        description: json['description'],
        categories: category ??
            (json['category'] as List).map((e) => e.toString()).toList() ??
            [],
        medias:
            (json['medias'] as List).map((e) => e.toString()).toList() ?? [],
        published: json['published']);
  }
  @override
  Map<String, dynamic> toJson() {
    // TODO: implement toJson
    throw UnimplementedError();
  }
}
copied to clipboard
Repository #
The repository abstract class will mediate between high level components of our architecture(Bloc and Client API Provider)
abstract class NewsRepository {
  Future<ResponseListData<NewsEnity>> fetchHotNews();
  Future<ResponseListData<NewsEnity>> fetchLocalNews();
}

enum _Path { Hot, Local }
class _URLPathHelper {
  static String value(_Path value) {
    switch (value) {
      case _Path.Hot:
        return '/application/news/hot';
      case _Path.Local:
        return '/application/news/local';
      default:
        return '';
    }
  }
}

class NewsClient extends APIProvider implements NewsRepository {
  @override
  Future<ResponseListData<NewsEnity>> fetchHotNews() async {
    var input = DefaultInputService(path: _URLPathHelper.value(_Path.Local));
    final response = await super.request(input: input);
    var result = (response.data['data'] as List)
        .map((e) => NewsEnity.fromJson(e))
        .toList();
    return ResponseListData<NewsEnity>(() => result);
  }
  @override
  Future<ResponseListData<NewsEnity>> fetchLocalNews() {
    return Future.error(AppError(message: ''));
  }
  NewsClient(
      {@required StorageTokenProcessor storageTokenProcessor,
      @required NetworkConfigurable networkConfigurable,
      Interceptor interceptor})
      : super(
            storageTokenProcessor: storageTokenProcessor,
            networkConfiguration: networkConfigurable,
            interceptor: interceptor);
}
copied to clipboard
Bloc #
Let’s add high level component of our architecture which is bloc (business logic component — read about it here).
NewsBlocis the only component which can be used from UI class (in terms of clean architecture). NewsBlocfetches data from repository and notify it via states.
class NewsBloc extends Bloc<NewsEvent, NewsState> {
  final NewsRepository newsRepository;
  final StorageTokenProcessor storageTokenProcessor;
  NewsBloc(
      {@required this.newsRepository, @required this.storageTokenProcessor})
      : super(NewsInitial());
  @override
  Stream<NewsState> mapEventToState(NewsEvent event) async* {
    if (event is FetchNews) {
      yield NewsLoading();
      yield* _fetchNews(event);
    }
  }
  Stream<NewsState> _fetchNews(FetchNews params) async* {
    try {
      var localNews = await newsRepository.fetchHotNews();
      yield NewsLoaded(hotNews: [], localNews: localNews.data);
    } on AppError catch (e, stack) {
      yield NewsError(message: e.message);
    }
  }
}

@immutable
abstract class NewsEvent {}

class FetchNews extends NewsEvent {}

@immutable
abstract class NewsState {}

class NewsLoaded extends NewsState {
final List<NewsEnity> hotNews;
final List<NewsEnity> localNews;
NewsLoaded({
@required this.hotNews,
@required this.localNews,
});
}
copied to clipboard