Merge pull request #333 from wer-mathurin/pedantic

Apply pedantic warning - to improve score point on pub.dev

Author: cloudwebrtc

analysis_options.yaml

@@ -0,0 +1 @@
+include: package:pedantic/analysis_options.yaml

example/lib/src/get_user_media_sample_web.dart

@@ -50,13 +50,13 @@ class _GetUserMediaSampleState extends State<GetUserMediaSample> {
   // Platform messages are asynchronous, so we initialize in an async method.
   _makeCall() async {
     final Map<String, dynamic> mediaConstraints = {
-      "audio": true,
-      "video": {
-        "mandatory": {
-          "minWidth":
+      'audio': true,
+      'video': {
+        'mandatory': {
+          'minWidth':
               '1280', // Provide your own width, height and frame rate here
-          "minHeight": '720',
-          "minFrameRate": '30',
+          'minHeight': '720',
+          'minFrameRate': '30',
         },
       }
     };
@@ -105,15 +105,15 @@ class _GetUserMediaSampleState extends State<GetUserMediaSample> {
   _captureFrame() async {
     final videoTrack = _localStream
         .getVideoTracks()
-        .firstWhere((track) => track.kind == "video");
+        .firstWhere((track) => track.kind == 'video');
     final frame = await videoTrack.captureFrame();
     showDialog(
         context: context,
         builder: (context) => AlertDialog(
               content: Image.network(frame, height: 720, width: 1280),
               actions: <Widget>[
                 FlatButton(
-                  child: Text("OK"),
+                  child: Text('OK'),
                   onPressed: Navigator.of(context, rootNavigator: true).pop,
                 )
               ],

lib/enums.dart

@@ -43,65 +43,65 @@ enum RTCVideoViewObjectFit {
 
 RTCIceConnectionState iceConnectionStateForString(String state) {
   switch (state) {
-    case "new":
+    case 'new':
       return RTCIceConnectionState.RTCIceConnectionStateNew;
-    case "checking":
+    case 'checking':
       return RTCIceConnectionState.RTCIceConnectionStateChecking;
-    case "connected":
+    case 'connected':
       return RTCIceConnectionState.RTCIceConnectionStateConnected;
-    case "completed":
+    case 'completed':
       return RTCIceConnectionState.RTCIceConnectionStateCompleted;
-    case "failed":
+    case 'failed':
       return RTCIceConnectionState.RTCIceConnectionStateFailed;
-    case "disconnected":
+    case 'disconnected':
       return RTCIceConnectionState.RTCIceConnectionStateDisconnected;
-    case "closed":
+    case 'closed':
       return RTCIceConnectionState.RTCIceConnectionStateClosed;
-    case "count":
+    case 'count':
       return RTCIceConnectionState.RTCIceConnectionStateCount;
   }
   return RTCIceConnectionState.RTCIceConnectionStateClosed;
 }
 
 RTCIceGatheringState iceGatheringStateforString(String state) {
   switch (state) {
-    case "new":
+    case 'new':
       return RTCIceGatheringState.RTCIceGatheringStateNew;
-    case "gathering":
+    case 'gathering':
       return RTCIceGatheringState.RTCIceGatheringStateGathering;
-    case "complete":
+    case 'complete':
       return RTCIceGatheringState.RTCIceGatheringStateComplete;
   }
   return RTCIceGatheringState.RTCIceGatheringStateNew;
 }
 
 RTCSignalingState signalingStateForString(String state) {
   switch (state) {
-    case "stable":
+    case 'stable':
       return RTCSignalingState.RTCSignalingStateStable;
-    case "have-local-offer":
+    case 'have-local-offer':
       return RTCSignalingState.RTCSignalingStateHaveLocalOffer;
-    case "have-local-pranswer":
+    case 'have-local-pranswer':
       return RTCSignalingState.RTCSignalingStateHaveLocalPrAnswer;
-    case "have-remote-offer":
+    case 'have-remote-offer':
       return RTCSignalingState.RTCSignalingStateHaveRemoteOffer;
-    case "have-remote-pranswer":
+    case 'have-remote-pranswer':
       return RTCSignalingState.RTCSignalingStateHaveRemotePrAnswer;
-    case "closed":
+    case 'closed':
       return RTCSignalingState.RTCSignalingStateClosed;
   }
   return RTCSignalingState.RTCSignalingStateClosed;
 }
 
 RTCDataChannelState rtcDataChannelStateForString(String state) {
   switch (state) {
-    case "connecting":
+    case 'connecting':
       return RTCDataChannelState.RTCDataChannelConnecting;
-    case "open":
+    case 'open':
       return RTCDataChannelState.RTCDataChannelOpen;
-    case "closing":
+    case 'closing':
       return RTCDataChannelState.RTCDataChannelClosing;
-    case "closed":
+    case 'closed':
       return RTCDataChannelState.RTCDataChannelClosed;
   }
   return RTCDataChannelState.RTCDataChannelClosed;

lib/get_user_media.dart

@@ -6,14 +6,14 @@ import 'utils.dart';
 class navigator {
   static Future<MediaStream> getUserMedia(
       Map<String, dynamic> mediaConstraints) async {
-    MethodChannel channel = WebRTC.methodChannel();
+    var channel = WebRTC.methodChannel();
     try {
-      final Map<dynamic, dynamic> response = await channel.invokeMethod(
+      final response = await channel.invokeMethod<Map<dynamic, dynamic>>(
         'getUserMedia',
         <String, dynamic>{'constraints': mediaConstraints},
       );
-      String streamId = response["streamId"];
-      MediaStream stream = new MediaStream(streamId, "local");
+      String streamId = response['streamId'];
+      var stream = MediaStream(streamId, 'local');
       stream.setMediaTracks(response['audioTracks'], response['videoTracks']);
       return stream;
     } on PlatformException catch (e) {
@@ -27,14 +27,14 @@ class navigator {
  * */
   static Future<MediaStream> getDisplayMedia(
       Map<String, dynamic> mediaConstraints) async {
-    MethodChannel channel = WebRTC.methodChannel();
+    var channel = WebRTC.methodChannel();
     try {
-      final Map<dynamic, dynamic> response = await channel.invokeMethod(
+      final response = await channel.invokeMethod<Map<dynamic, dynamic>>(
         'getDisplayMedia',
         <String, dynamic>{'constraints': mediaConstraints},
       );
-      String streamId = response["streamId"];
-      MediaStream stream = new MediaStream(streamId, "local");
+      String streamId = response['streamId'];
+      var stream = MediaStream(streamId, 'local');
       stream.setMediaTracks(response['audioTracks'], response['videoTracks']);
       return stream;
     } on PlatformException catch (e) {
@@ -43,13 +43,13 @@ class navigator {
   }
 
   static Future<List<dynamic>> getSources() async {
-    MethodChannel channel = WebRTC.methodChannel();
+    var channel = WebRTC.methodChannel();
     try {
-      final Map<dynamic, dynamic> response = await channel.invokeMethod(
+      final response = await channel.invokeMethod<Map<dynamic, dynamic>>(
         'getSources',
         <String, dynamic>{},
       );
-      List<dynamic> sources = response["sources"];
+      List<dynamic> sources = response['sources'];
       return sources;
     } on PlatformException catch (e) {
       throw 'Unable to getSources: ${e.message}';

lib/media_recorder.dart

@@ -14,9 +14,13 @@ class MediaRecorder {
       {MediaStreamTrack videoTrack, RecorderAudioChannel audioChannel
       //TODO: add codec/quality options
       }) async {
-    if (path == null) throw ArgumentError.notNull("path");
-    if (audioChannel == null && videoTrack == null)
-      throw Exception("Neither audio nor video track were provided");
+    if (path == null) {
+      throw ArgumentError.notNull('path');
+    }
+
+    if (audioChannel == null && videoTrack == null) {
+      throw Exception('Neither audio nor video track were provided');
+    }
 
     await WebRTC.methodChannel().invokeMethod('startRecordToFile', {
       'path': path,
@@ -29,7 +33,7 @@ class MediaRecorder {
   void startWeb(MediaStream stream,
       {Function(dynamic blob, bool isLastOne) onDataChunk,
       String mimeType = 'video/mp4;codecs=h264'}) {
-    throw "It's for Flutter Web only";
+    throw 'It\'s for Flutter Web only';
   }
 
   Future<dynamic> stop() async => await WebRTC.methodChannel()

lib/media_stream.dart

@@ -7,32 +7,30 @@ class MediaStream {
   final MethodChannel _channel = WebRTC.methodChannel();
   final String _streamId;
   final String _ownerTag;
-  List<MediaStreamTrack> _audioTracks = List<MediaStreamTrack>();
-  List<MediaStreamTrack> _videoTracks = List<MediaStreamTrack>();
+  final _audioTracks = <MediaStreamTrack>[];
+  final _videoTracks = <MediaStreamTrack>[];
 
   MediaStream(this._streamId, this._ownerTag);
 
   String get ownerTag => _ownerTag;
   String get id => _streamId;
 
   void setMediaTracks(List<dynamic> audioTracks, List<dynamic> videoTracks) {
-    var newAudioTracks = List<MediaStreamTrack>();
+    _audioTracks.clear();
     audioTracks.forEach((track) {
-      newAudioTracks.add(MediaStreamTrack(
-          track["id"], track["label"], track["kind"], track["enabled"]));
+      _audioTracks.add(MediaStreamTrack(
+          track['id'], track['label'], track['kind'], track['enabled']));
     });
-    this._audioTracks = newAudioTracks;
 
-    var newVideoTracks = List<MediaStreamTrack>();
+    _videoTracks.clear();
     videoTracks.forEach((track) {
-      newVideoTracks.add(MediaStreamTrack(
-          track["id"], track["label"], track["kind"], track["enabled"]));
+      _videoTracks.add(MediaStreamTrack(
+          track['id'], track['label'], track['kind'], track['enabled']));
     });
-    this._videoTracks = newVideoTracks;
   }
 
   Future<void> getMediaTracks() async {
-    final Map<dynamic, dynamic> response = await _channel.invokeMethod(
+    final response = await _channel.invokeMethod<Map<dynamic, dynamic>>(
       'mediaStreamGetTracks',
       <String, dynamic>{'streamId': _streamId},
     );
@@ -42,26 +40,30 @@ class MediaStream {
 
   Future<void> addTrack(MediaStreamTrack track,
       {bool addToNative = true}) async {
-    if (track.kind == 'audio')
+    if (track.kind == 'audio') {
       _audioTracks.add(track);
-    else
+    } else {
       _videoTracks.add(track);
+    }
 
-    if (addToNative)
+    if (addToNative) {
       await _channel.invokeMethod('mediaStreamAddTrack',
           <String, dynamic>{'streamId': _streamId, 'trackId': track.id});
+    }
   }
 
   Future<void> removeTrack(MediaStreamTrack track,
       {bool removeFromNative = true}) async {
-    if (track.kind == 'audio')
+    if (track.kind == 'audio') {
       _audioTracks.removeWhere((it) => it.id == track.id);
-    else
+    } else {
       _videoTracks.removeWhere((it) => it.id == track.id);
+    }
 
-    if (removeFromNative)
+    if (removeFromNative) {
       await _channel.invokeMethod('mediaStreamRemoveTrack',
           <String, dynamic>{'streamId': _streamId, 'trackId': track.id});
+    }
   }
 
   List<MediaStreamTrack> getAudioTracks() {

lib/media_stream_track.dart

@@ -1,13 +1,11 @@
 import 'dart:async';
-
-import 'package:flutter/services.dart';
 import 'utils.dart';
 
 class MediaStreamTrack {
-  MethodChannel _channel = WebRTC.methodChannel();
-  String _trackId;
-  String _label;
-  String _kind;
+  final _channel = WebRTC.methodChannel();
+  final String _trackId;
+  final String _label;
+  final String _kind;
   bool _enabled;
 
   MediaStreamTrack(this._trackId, this._label, this._kind, this._enabled);
@@ -64,10 +62,12 @@ class MediaStreamTrack {
   }
 
   /// On Flutter Web returns Future<dynamic> which contains data url on success
-  captureFrame([String filePath]) => _channel.invokeMethod(
-        'captureFrame',
-        <String, dynamic>{'trackId': _trackId, 'path': filePath},
-      );
+  Future<dynamic> captureFrame([String filePath]) {
+    return _channel.invokeMethod<void>(
+      'captureFrame',
+      <String, dynamic>{'trackId': _trackId, 'path': filePath},
+    );
+  }
 
   Future<void> dispose() async {
     await _channel.invokeMethod(