akhil/1340/fetching_the_list_of_wallets_available_to_create

analysis_options.yaml

@@ -2,9 +2,9 @@ analyzer:
   exclude:
     - lib/basic_api/generated/api.dart
 
-  strong-mode:
-    implicit-dynamic: false
-
+  language:
+    strict-raw-types: true
+    
   errors:
     todo: ignore
     missing_required_param: warning
@@ -92,7 +92,6 @@ linter:
     - prefer_const_literals_to_create_immutables
     - prefer_constructors_over_static_methods
     - prefer_contains
-    - prefer_equal_for_default_values
     - prefer_expression_function_bodies # https://github.com/flutter/flutter/wiki/Style-guide-for-Flutter-repo#consider-using--for-short-functions-and-methods
     - prefer_final_fields
     - prefer_final_in_for_each

android/build.gradle

@@ -2,14 +2,14 @@ group 'com.deriv.flutter_deriv_api'
 version '1.0-SNAPSHOT'
 
 buildscript {
-    ext.kotlin_version = '1.3.50'
+    ext.kotlin_version = '1.7.10'
     repositories {
         google()
         jcenter()
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.5.0'
+        classpath 'com.android.tools.build:gradle:7.3.0'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
     }
 }

android/gradle/wrapper/gradle-wrapper.properties

@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.2-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.1-all.zip

api_builder.dart

@@ -122,8 +122,8 @@ class APIBuilder extends Builder {
               /// Initialize $classFullName.
               const $classFullName({
                   ${_getConstructorParameters(methodName, schema, schemaType, properties)}
-                  ${_getSuperClassParameters(schemaType)},
-                }): super(${_getSuperClassCallParameters(schemaType, methodName)},);
+                  ${_getSuperClassConstructorParameters(schemaType, methodName)},
+                });
 
               ${_getFromJsonMethod(classFullName, schema, schemaType, properties)}
 
@@ -169,6 +169,7 @@ class APIBuilder extends Builder {
         return '${_isFieldRequired(key, schemaType, property) ? 'required ' : ''} this.${ReCase(key).camelCase}';
       },
     ).join(', ');
+
     return fields.isEmpty ? result : '$result , ';
   }
 
@@ -380,6 +381,7 @@ class APIBuilder extends Builder {
         fields.map(
           (String key) {
             final String name = ReCase(key).camelCase;
+
             return '$name: $name ?? this.$name';
           },
         ).join(', '),
@@ -388,40 +390,45 @@ class APIBuilder extends Builder {
       ..write('${_getSupperClassAssignments(schemaType)},);');
   }
 
-  static String _getSuperClassParameters(String? schemaType) {
+  static String _getSuperClassParameters(String schemaType) {
     final Map<String, String> superClassFields =
         _getSuperClassFields(schemaType);
 
-    return superClassFields.keys
-        .map((String key) =>
-            '${typeMap[superClassFields[key]!]} ${ReCase(key).camelCase}')
-        .join(', ');
+    final Iterable<String> parameters = superClassFields.keys.map((String key) {
+      final String type = typeMap[superClassFields[key]!] ?? 'dynamic';
+      final String parameterName = ReCase(key).camelCase;
+
+      return '$type $parameterName';
+    });
+
+    return parameters.join(', ');
   }
 
-  static String _getSuperClassCallParameters(
+  static String _getSuperClassConstructorParameters(
     String schemaType,
     String methodName,
   ) {
-    final StringBuffer superCallParameters = StringBuffer();
+    final Map<String, String> superClassFields =
+        _getSuperClassFields(schemaType);
+    final StringBuffer superClassParameters = StringBuffer();
 
     if (schemaType == 'send') {
-      superCallParameters.write('msgType: \'$methodName\',');
+      superClassParameters.write('super.msgType = \'$methodName\', ');
     }
 
-    superCallParameters.write(_getSuperClassFields(schemaType).keys.map(
-      (String key) {
-        final String parameterName = ReCase(key).camelCase;
-        return '$parameterName: $parameterName';
-      },
-    ).join(', '));
+    final Iterable<String> parameters = superClassFields.keys
+        .map((String key) => 'super.${ReCase(key).camelCase}');
 
-    return superCallParameters.toString();
+    superClassParameters.write(parameters.join(', '));
+
+    return superClassParameters.toString();
   }
 
   static String _getSupperClassAssignments(String schemaType) =>
       _getSuperClassFields(schemaType).keys.map(
         (String key) {
           final String propertyName = ReCase(key).camelCase;
+
           return '$propertyName: $propertyName ?? this.$propertyName';
         },
       ).join(', ');
@@ -458,7 +465,7 @@ class APIBuilder extends Builder {
   }
 }
 
-class GeneratedResponseJson extends Comparable<GeneratedResponseJson> {
+class GeneratedResponseJson implements Comparable<GeneratedResponseJson> {
   GeneratedResponseJson({
     this.msgType,
     this.fileName,

example/android/app/build.gradle

@@ -26,7 +26,7 @@ apply plugin: 'kotlin-android'
 apply from: "$flutterRoot/packages/flutter_tools/gradle/flutter.gradle"
 
 android {
-    compileSdkVersion 28
+    compileSdkVersion 33
 
     sourceSets {
         main.java.srcDirs += 'src/main/kotlin'

example/android/build.gradle

@@ -1,12 +1,12 @@
 buildscript {
-    ext.kotlin_version = '1.3.50'
+    ext.kotlin_version = '1.7.10'
     repositories {
         google()
         jcenter()
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.5.0'
+        classpath 'com.android.tools.build:gradle:7.3.0'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
     }
 }
@@ -26,6 +26,6 @@ subprojects {
     project.evaluationDependsOn(':app')
 }
 
-task clean(type: Delete) {
+tasks.register("clean", Delete) {
     delete rootProject.buildDir
 }

example/android/gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.6.2-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.1-all.zip

example/lib/blocs/active_symbols/active_symbols_bloc.dart

@@ -11,31 +11,40 @@ part 'active_symbols_state.dart';
 /// ActiveSymbolsBloc
 class ActiveSymbolsBloc extends Bloc<ActiveSymbolsEvent, ActiveSymbolsState> {
   /// ActiveSymbolsBloc initializer
-  ActiveSymbolsBloc() : super(ActiveSymbolsLoading());
-
-  @override
-  Stream<ActiveSymbolsState> mapEventToState(ActiveSymbolsEvent event) async* {
-    if (event is FetchActiveSymbols) {
-      yield ActiveSymbolsLoading();
-
-      try {
-        final ActiveSymbolsResponse symbols = await _fetchActiveSymbols();
-        yield ActiveSymbolsLoaded(activeSymbols: symbols.activeSymbols!);
-      } on ActiveSymbolsException catch (error) {
-        yield ActiveSymbolsError(error.message);
-      }
-    } else if (event is SelectActiveSymbol) {
-      if (state is ActiveSymbolsLoaded) {
-        final ActiveSymbolsLoaded loadedState = state as ActiveSymbolsLoaded;
-
-        yield ActiveSymbolsLoaded(
-          activeSymbols: loadedState.activeSymbols,
-          selectedSymbol: loadedState.activeSymbols[event.index],
-        );
-      } else {
-        yield ActiveSymbolsLoading();
-        add(FetchActiveSymbols());
-      }
+  ActiveSymbolsBloc() : super(ActiveSymbolsLoading()) {
+    on<FetchActiveSymbols>(
+        (FetchActiveSymbols event, Emitter<ActiveSymbolsState> emit) =>
+            _handleFetchActiveSymbols(event, emit));
+
+    on<SelectActiveSymbol>(
+        (SelectActiveSymbol event, Emitter<ActiveSymbolsState> emit) =>
+            _handleSelectActiveSymbol(event, emit));
+  }
+
+  Future<void> _handleFetchActiveSymbols(
+      FetchActiveSymbols event, Emitter<ActiveSymbolsState> emit) async {
+    emit(ActiveSymbolsLoading());
+
+    try {
+      final ActiveSymbolsResponse symbols = await _fetchActiveSymbols();
+      emit(ActiveSymbolsLoaded(activeSymbols: symbols.activeSymbols!));
+    } on BaseAPIException catch (error) {
+      emit(ActiveSymbolsError(error.message));
+    }
+  }
+
+  Future<void> _handleSelectActiveSymbol(
+      SelectActiveSymbol event, Emitter<ActiveSymbolsState> emit) async {
+    if (state is ActiveSymbolsLoaded) {
+      final ActiveSymbolsLoaded loadedState = state as ActiveSymbolsLoaded;
+
+      emit(ActiveSymbolsLoaded(
+        activeSymbols: loadedState.activeSymbols,
+        selectedSymbol: loadedState.activeSymbols[event.index],
+      ));
+    } else {
+      emit(ActiveSymbolsLoading());
+      add(FetchActiveSymbols());
     }
   }
 

example/lib/blocs/available_contracts/available_contracts_bloc.dart

@@ -26,36 +26,47 @@ class AvailableContractsBloc
         );
       }
     });
+
+    on<FetchAvailableContracts>((FetchAvailableContracts event,
+            Emitter<AvailableContractsState> emit) =>
+        _handleFetchAvailableContracts(event, emit));
+
+    on<SelectContract>(
+        (SelectContract event, Emitter<AvailableContractsState> emit) =>
+            _handleSelectContract(event, emit));
   }
 
-  @override
-  Stream<AvailableContractsState> mapEventToState(
-    AvailableContractsEvent event,
-  ) async* {
-    if (event is FetchAvailableContracts) {
-      yield AvailableContractsLoading();
+  Future<void> _handleFetchAvailableContracts(
+    FetchAvailableContracts event,
+    Emitter<AvailableContractsState> emit,
+  ) async {
+    emit(AvailableContractsLoading());
 
-      try {
-        final ContractsForResponse contracts =
-            await _fetchAvailableContracts(event.activeSymbol);
+    try {
+      final ContractsForResponse contracts =
+          await _fetchAvailableContracts(event.activeSymbol);
 
-        yield AvailableContractsLoaded(contracts: contracts.contractsFor!);
-      } on ContractsForSymbolException catch (error) {
-        yield AvailableContractsError(error.message);
-      }
-    } else if (event is SelectContract) {
-      if (state is AvailableContractsLoaded) {
-        final AvailableContractsLoaded loadedState =
-            state as AvailableContractsLoaded;
+      emit(AvailableContractsLoaded(contracts: contracts.contractsFor!));
+    } on BaseAPIException catch (error) {
+      emit(AvailableContractsError(error.message));
+    }
+  }
 
-        yield AvailableContractsLoaded(
-          contracts: loadedState.contracts,
-          selectedContract: loadedState.contracts.available[event.index],
-        );
-      } else {
-        yield AvailableContractsLoading();
-        add(FetchAvailableContracts());
-      }
+  void _handleSelectContract(
+    SelectContract event,
+    Emitter<AvailableContractsState> emit,
+  ) {
+    if (state is AvailableContractsLoaded) {
+      final AvailableContractsLoaded loadedState =
+          state as AvailableContractsLoaded;
+
+      emit(AvailableContractsLoaded(
+        contracts: loadedState.contracts,
+        selectedContract: loadedState.contracts.available[event.index],
+      ));
+    } else {
+      emit(AvailableContractsLoading());
+      add(FetchAvailableContracts());
     }
   }
 

example/lib/blocs/price_proposal/price_proposal_bloc.dart

@@ -22,28 +22,33 @@ class PriceProposalBloc extends Bloc<PriceProposalEvent, PriceProposalState> {
         add(SubscribeProposal(state.selectedContract));
       }
     });
+
+    on<SubscribeProposal>(
+        (SubscribeProposal event, Emitter<PriceProposalState> emit) =>
+            _handleSubscribeProposal(event, emit));
+
+    on<YieldProposalLoaded>(
+        (YieldProposalLoaded event, Emitter<PriceProposalState> emit) =>
+            emit(PriceProposalLoaded(event.proposal.proposal)));
+
+    on<YieldError>((YieldError event, Emitter<PriceProposalState> emit) =>
+        emit(PriceProposalError(event.message)));
   }
 
-  @override
-  Stream<PriceProposalState> mapEventToState(
-    PriceProposalEvent event,
-  ) async* {
-    if (event is SubscribeProposal) {
-      yield PriceProposalLoading();
+  Future<void> _handleSubscribeProposal(
+    SubscribeProposal event,
+    Emitter<PriceProposalState> emit,
+  ) async {
+    emit(PriceProposalLoading());
 
-      await _unsubscribeProposal();
+    await _unsubscribeProposal();
 
-      _subscribeProposal(event)
-          .handleError((dynamic error) => error is ContractOperationException
-              ? add(YieldError(error.message))
-              : add(YieldError(error.toString())))
-          .listen((ProposalResponse? proposal) =>
-              add(YieldProposalLoaded(proposal!)));
-    } else if (event is YieldProposalLoaded) {
-      yield PriceProposalLoaded(event.proposal.proposal);
-    } else if (event is YieldError) {
-      yield PriceProposalError(event.message);
-    }
+    _subscribeProposal(event)
+        .handleError((dynamic error) => error is BaseAPIException
+            ? add(YieldError(error.message))
+            : add(YieldError(error.toString())))
+        .listen((ProposalResponse? proposal) =>
+            add(YieldProposalLoaded(proposal!)));
   }
 
   Stream<ProposalResponse?> _subscribeProposal(SubscribeProposal event) =>