feat(stats) migrate RN to new stats

modules/statistics/RTPStatsCollector.js

     'port': 'port',
     'protocol': 'protocol'
 };
+KEYS_BY_BROWSER_TYPE[browsers.REACT_NATIVE] = {
+    'packetsReceived': 'packetsReceived',
+    'packetsSent': 'packetsSent',
+    'bytesReceived': 'bytesReceived',
+    'bytesSent': 'bytesSent',
+    'frameWidth': 'frameWidth',
+    'frameHeight': 'frameHeight',
+    'framesPerSecond': 'framesPerSecond',
+    'ip': 'ip',
+    'port': 'port',
+    'protocol': 'protocol'
+};
 KEYS_BY_BROWSER_TYPE[browsers.OPERA]
     = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
 KEYS_BY_BROWSER_TYPE[browsers.NWJS]
     = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
 KEYS_BY_BROWSER_TYPE[browsers.SAFARI]
     = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
-KEYS_BY_BROWSER_TYPE[browsers.REACT_NATIVE]
-    = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
 
 /**
  * Calculates packet lost percent using the number of lost packets and the
     const keys = KEYS_BY_BROWSER_TYPE[this._browserType];
 
     if (!keys) {
-        // eslint-disable-next-line no-throw-literal
-        throw `The browser type '${this._browserType}' isn't supported!`;
+        throw new Error(`The browser type '${this._browserType}' isn't supported!`);
     }
 
     /**
      * @type {boolean}
      */
     this._usesPromiseGetStats
-        = browser.isSafari() || browser.isFirefox();
+        = browser.isSafari() || browser.isFirefox() || browser.isReactNative();
 
     /**
      * The function which is to be used to retrieve the value associated in a
             return key;
         }
 
-        // eslint-disable-next-line no-throw-literal
-        throw `The property '${name}' isn't supported!`;
+        throw new Error(`The property '${name}' isn't supported!`);
     };
 
     // Define the function which retrieves the value from a specific report
         // retrieve the value associated with a specific key.
         itemStatByKey = (item, key) => item.stat(key);
         break;
-    case browsers.REACT_NATIVE:
-        // The implementation provided by react-native-webrtc follows the
-        // Objective-C WebRTC API: RTCStatsReport has a values property of type
-        // Array in which each element is a key-value pair.
-        itemStatByKey = function(item, key) {
-            let value;
-
-            item.values.some(pair => {
-                if (pair.hasOwnProperty(key)) {
-                    value = pair[key];
-
-                    return true;
-                }
-
-                return false;
-
-            });
-
-            return value;
-        };
-        break;
     default:
         itemStatByKey = (item, key) => item[key];
     }
     const codecs = {};
     let audioBitrateDownload = 0;
     let audioBitrateUpload = 0;
-    let audioCodec = '';
+    let audioCodec;
     let videoBitrateDownload = 0;
     let videoBitrateUpload = 0;
-    let videoCodec = '';
+    let videoCodec;
 
     for (const [ ssrc, ssrcStats ] of this.ssrc2stats) {
         // process packet loss stats
                     userFramerates[ssrc] = ssrcStats.framerate;
                     framerates[participantId] = userFramerates;
                 }
-                if (audioCodec.length && videoCodec.length) {
+                if (audioCodec && videoCodec) {
                     const codecDesc = {
                         'audio': audioCodec,
                         'video': videoCodec
             return key;
         }
 
-        // eslint-disable-next-line no-throw-literal
-        throw `The property '${name}' isn't supported!`;
+        throw new Error(`The property '${name}' isn't supported!`);
     };
 
     // Compose the 2 functions defined above to get a function which retrieves
                 isDownloadStream
             });
 
+            const resolution = {
+                height: null,
+                width: null
+            };
+
+            try {
+                resolution.height = getStatValue(now, 'frameHeight');
+                resolution.width = getStatValue(now, 'frameWidth');
+            } catch (e) { /* not supported*/ }
+
+            // Tries to get frame rate
+            let frameRate;
+
+            try {
+                frameRate = getStatValue(now, 'framesPerSecond');
+            } catch (err) { /* not supported*/ }
+
+            ssrcStats.setFramerate(Math.round(frameRate || 0));
+
+            if (resolution.height && resolution.width) {
+                ssrcStats.setResolution(resolution);
+            } else {
+                ssrcStats.setResolution(null);
+            }
+
             if (now.type === 'inbound-rtp') {
 
                 ssrcStats.addBitrate({
                 ssrcStats.setFramerate(Math.round(framerateMean || 0));
             }
 
+
+            let codec;
+
+            // Try to get the codec for later reporting.
+            try {
+                codec = this.currentStatsReport.get(now.codecId);
+            } catch (e) { /* not supported*/ }
+
+            /*
+               The mime type has the following form: video/VP8 or audio/ISAC,
+               so we what to keep just the type after the '/', audio and video
+               keys will be added on the processing side.
+            */
+            const codecShortType = codec.mimeType.split('/')[1];
+
+            ssrcStats.setCodec(codecShortType);
+
         // track for resolution
         // RTCVideoHandlerStats
         // https://w3c.github.io/webrtc-stats/#vststats-dict*