@wemap/positioning 2.7.9 → 2.7.11

package/debug/components/ArCoreAbsoluteComponent.jsx

@@ -48,57 +48,57 @@ class ArCoreAbsoluteComponent extends React.Component {
         }
     }
 
-  onEvent = events => {
-      const newState = {};
-      events.forEach(event => {
-          if (event.dataType === EventType.AbsolutePosition) {
-              newState.position = event.data;
-          } else if (event.dataType === EventType.AbsoluteAttitude) {
-              newState.attitude = event.data;
-          } else if (event.dataType === EventType.Barcode) {
-              newState.barcode = event.data;
-          }
-      });
-      if (!isEmpty(newState)) {
-          this.setState(newState);
-      }
-
-      if (this.map) {
-          this.map.parseEvents(events);
-      }
-  };
-
-  onError = error => {
-      this.errored = true;
-      this.setState({
-          position: error,
-          attitude: error
-      });
-  };
-
-  render() {
-      const {barcode} = this.state;
-
-      const attitudeRender = Utils.renderAttitude(this.state.attitude);
-      const positionRender = Utils.renderPosition(this.state.position);
-
-      return (
-          <div>
-              <h3>Position</h3>
-              {positionRender}
-              <h3>Attitude</h3>
-              {attitudeRender}
-              <h3>Barcode</h3>
-              {barcode ? barcode : ''}
-              <h3>Map</h3>
-              <MapComponent
-                  ref={map => (this.map = map)}
-                  defaultZoom={21}
-                  network={NavigationConfig.ITINERARY}
-              />
-          </div>
-      );
-  }
+    onEvent = events => {
+        const newState = {};
+        events.forEach(event => {
+            if (event.dataType === EventType.AbsolutePosition) {
+                newState.position = event.data;
+            } else if (event.dataType === EventType.AbsoluteAttitude) {
+                newState.attitude = event.data;
+            } else if (event.dataType === EventType.Barcode) {
+                newState.barcode = event.data;
+            }
+        });
+        if (!isEmpty(newState)) {
+            this.setState(newState);
+        }
+
+        if (this.map) {
+            this.map.parseEvents(events);
+        }
+    };
+
+    onError = error => {
+        this.errored = true;
+        this.setState({
+            position: error,
+            attitude: error
+        });
+    };
+
+    render() {
+        const {barcode} = this.state;
+
+        const attitudeRender = Utils.renderAttitude(this.state.attitude);
+        const positionRender = Utils.renderPosition(this.state.position);
+
+        return (
+            <div>
+                <h3>Position</h3>
+                {positionRender}
+                <h3>Attitude</h3>
+                {attitudeRender}
+                <h3>Barcode</h3>
+                {barcode ? barcode : ''}
+                <h3>Map</h3>
+                <MapComponent
+                    ref={map => (this.map = map)}
+                    defaultZoom={21}
+                    network={NavigationConfig.ITINERARY}
+                />
+            </div>
+        );
+    }
 }
 
 export default ArCoreAbsoluteComponent;

package/debug/components/GnssWifiPdrComponent.jsx

@@ -30,47 +30,47 @@ class GnssWifiPdrComponent extends React.Component {
         this.gnssWifiPdrProvider.stop();
     }
 
-  onEvent = events => {
-      const newState = {};
-      events.forEach(event => {
-          if (event.dataType === EventType.AbsolutePosition) {
-              newState.position = event.data;
-          } else if (event.dataType === EventType.AbsoluteAttitude) {
-              newState.attitude = event.data;
-          }
-      });
-      if (!isEmpty(newState)) {
-          this.setState(newState);
-      }
+    onEvent = events => {
+        const newState = {};
+        events.forEach(event => {
+            if (event.dataType === EventType.AbsolutePosition) {
+                newState.position = event.data;
+            } else if (event.dataType === EventType.AbsoluteAttitude) {
+                newState.attitude = event.data;
+            }
+        });
+        if (!isEmpty(newState)) {
+            this.setState(newState);
+        }
 
-      if (this.map) {
-          this.map.parseEvents(events);
-      }
-  };
+        if (this.map) {
+            this.map.parseEvents(events);
+        }
+    };
 
-  onError = error => {
-      this.setState({
-          position: error,
-          attitude: error
-      });
-  };
+    onError = error => {
+        this.setState({
+            position: error,
+            attitude: error
+        });
+    };
 
-  render() {
-      const attitudeRender = Utils.renderAttitude(this.state.attitude);
-      const positionRender = Utils.renderPosition(this.state.position);
+    render() {
+        const attitudeRender = Utils.renderAttitude(this.state.attitude);
+        const positionRender = Utils.renderPosition(this.state.position);
 
-      return (
-          <div>
-              <h3>Position</h3>
-              {positionRender}
-              <h3>Attitude</h3>
-              {attitudeRender}
-              <h3>Map</h3>
-              <MapComponent ref={map => (this.map = map)}
-                  network={NavigationConfig.ITINERARY} />
-          </div>
-      );
-  }
+        return (
+            <div>
+                <h3>Position</h3>
+                {positionRender}
+                <h3>Attitude</h3>
+                {attitudeRender}
+                <h3>Map</h3>
+                <MapComponent ref={map => (this.map = map)}
+                    network={NavigationConfig.ITINERARY} />
+            </div>
+        );
+    }
 }
 
 export default GnssWifiPdrComponent;

package/debug/components/MapComponent.jsx

@@ -11,7 +11,7 @@ import { Network } from '@wemap/graph';
 import EventType from '../../src/events/EventType';
 
 mapboxgl.accessToken
-  = 'pk.eyJ1IjoibWFwYm94IiwiYSI6ImNpejY4M29iazA2Z2gycXA4N2pmbDZmangifQ.-g_vE53SD2WrJ6tFX7QHmA';
+    = 'pk.eyJ1IjoibWFwYm94IiwiYSI6ImNpejY4M29iazA2Z2gycXA4N2pmbDZmangifQ.-g_vE53SD2WrJ6tFX7QHmA';
 
 const COMPASS_STYLE = {
     width: '15px',
@@ -38,191 +38,191 @@ const POSITION_STYLE = {
 };
 
 class MapComponent extends React.Component {
-  static propTypes = {
-      network: PropTypes.instanceOf(Network),
-      defaultZoom: PropTypes.number
-  };
-
-  static defaultProps = { defaultZoom: 19 };
-
-  componentDidMount() {
-      this.map = new mapboxgl.Map({
-          container: this.mapContainer,
-          style: 'mapbox://styles/mapbox/streets-v9'
-      });
-      this.renderNetwork();
-  }
-
-  componentWillUnmount() {
-      this.map.remove();
-  }
-
-  createMarker(options) {
-      var elem, marker;
-
-      elem = document.createElement('div');
-      elem.style.marginLeft = '-' + options.iconAnchor[0] + 'px';
-      elem.style.marginTop = '-' + options.iconAnchor[1] + 'px';
-      elem.style.width = 0;
-      elem.style.height = 0;
-      elem.appendChild(options.dom);
-
-      marker = new mapboxgl.Marker(elem);
-      marker.setLngLat([options.longitude, options.latitude]);
-      return marker;
-  }
-
-  createPositionMarker(position) {
-      const coreIcon = document.createElement('div');
-      this.applyStyleToDomElement(coreIcon, POSITION_STYLE);
-
-      this.positionIcon = document.createElement('div');
-      this.positionIcon.appendChild(coreIcon);
-
-      return this.createMarker({
-          dom: this.positionIcon,
-          iconAnchor: [0, 0],
-          latitude: position[1],
-          longitude: position[0]
-      });
-  }
-
-  createCompassElement() {
-      if (!this.positionIcon) {
-          throw new Error('createPositionMarker() should be called before');
-      }
-      this.compassIcon = document.createElement('div');
-      this.applyStyleToDomElement(this.compassIcon, COMPASS_STYLE);
-      this.positionIcon.appendChild(this.compassIcon);
-  }
-
-  applyStyleToDomElement(domElement, style) {
-      for (const key in style) {
-          if (style.hasOwnProperty(key)) {
-              domElement.style[key] = style[key];
-          }
-      }
-  }
-
-  parseEvents(events) {
-      if (!this.map) {
-          return;
-      }
-      events.forEach(event => {
-          if (event.dataType === EventType.AbsolutePosition) {
-              this.updatePosition(event.data);
-          } else if (event.dataType === EventType.AbsoluteAttitude) {
-              this.updateAttitude(event.data);
-          }
-      });
-  }
-
-  updatePosition(position) {
-      if (!this.map) {
-          return;
-      }
-
-      if (!(position instanceof WGS84)) {
-          if (this.mapMarker) {
-              this.mapMarker.remove();
-              this.mapMarker = null;
-              this.positionIcon = null;
-          }
-          return;
-      }
-
-      const lngLat = [position.lng, position.lat];
-
-      if (!this.mapMarker) {
-          this.mapMarker = this.createPositionMarker(lngLat).addTo(this.map);
-          this.map.jumpTo({
-              center: lngLat,
-              zoom: this.props.defaultZoom
-          });
-      } else {
-          this.mapMarker.setLngLat(lngLat);
-      }
-  }
-
-  updateAttitude(attitude) {
-      if (!this.positionIcon) {
-          return;
-      }
-
-      if (!(attitude instanceof Attitude)) {
-          if (this.compassIcon) {
-              this.positionIcon.removeChild(this.compassIcon);
-          }
-          return;
-      }
-
-      if (!this.compassIcon) {
-          this.createCompassElement();
-      }
-
-      this.positionIcon.style.transform
-      = 'rotate(' + attitude.headingDegrees + 'deg)';
-  }
-
-  renderNetwork() {
-      if (!this.map) {
-          return;
-      }
-
-      const network = this.props.network;
-
-      if (network === this.previousNetwork) {
-          return;
-      }
-      this.previousNetwork = network;
-
-      if (!network) {
-          if (this.networkLayer) {
-              this.map.removeLayer(this.networkLayer);
-              this.networkLayer = null;
-          }
-          return;
-      }
-
-      const layer = {
-          id: 'network',
-          type: 'line',
-          source: {
-              type: 'geojson',
-              data: {
-                  type: 'Feature',
-                  properties: {},
-                  geometry: {
-                      type: 'MultiLineString',
-                      coordinates: []
-                  }
-              }
-          },
-          paint: {
-              'line-color': '#0000FF',
-              'line-width': 3
-          }
-      };
-
-      for (let i = 0; i < network.edges.length; i++) {
-          layer.source.data.geometry.coordinates.push([
-              [network.edges[i].node1.coords.lng, network.edges[i].node1.coords.lat],
-              [network.edges[i].node2.coords.lng, network.edges[i].node2.coords.lat]
-          ]);
-      }
-
-      this.map.on('load', () => {
-          this.networkLayer = this.map.addLayer(layer);
-      });
-  }
-
-  render() {
-      this.renderNetwork();
-      return (
-          <div ref={map => (this.mapContainer = map)}
-              style={{ height: '300px' }} />
-      );
-  }
+    static propTypes = {
+        network: PropTypes.instanceOf(Network),
+        defaultZoom: PropTypes.number
+    };
+
+    static defaultProps = { defaultZoom: 19 };
+
+    componentDidMount() {
+        this.map = new mapboxgl.Map({
+            container: this.mapContainer,
+            style: 'mapbox://styles/mapbox/streets-v9'
+        });
+        this.renderNetwork();
+    }
+
+    componentWillUnmount() {
+        this.map.remove();
+    }
+
+    createMarker(options) {
+        var elem, marker;
+
+        elem = document.createElement('div');
+        elem.style.marginLeft = '-' + options.iconAnchor[0] + 'px';
+        elem.style.marginTop = '-' + options.iconAnchor[1] + 'px';
+        elem.style.width = 0;
+        elem.style.height = 0;
+        elem.appendChild(options.dom);
+
+        marker = new mapboxgl.Marker(elem);
+        marker.setLngLat([options.longitude, options.latitude]);
+        return marker;
+    }
+
+    createPositionMarker(position) {
+        const coreIcon = document.createElement('div');
+        this.applyStyleToDomElement(coreIcon, POSITION_STYLE);
+
+        this.positionIcon = document.createElement('div');
+        this.positionIcon.appendChild(coreIcon);
+
+        return this.createMarker({
+            dom: this.positionIcon,
+            iconAnchor: [0, 0],
+            latitude: position[1],
+            longitude: position[0]
+        });
+    }
+
+    createCompassElement() {
+        if (!this.positionIcon) {
+            throw new Error('createPositionMarker() should be called before');
+        }
+        this.compassIcon = document.createElement('div');
+        this.applyStyleToDomElement(this.compassIcon, COMPASS_STYLE);
+        this.positionIcon.appendChild(this.compassIcon);
+    }
+
+    applyStyleToDomElement(domElement, style) {
+        for (const key in style) {
+            if (style.hasOwnProperty(key)) {
+                domElement.style[key] = style[key];
+            }
+        }
+    }
+
+    parseEvents(events) {
+        if (!this.map) {
+            return;
+        }
+        events.forEach(event => {
+            if (event.dataType === EventType.AbsolutePosition) {
+                this.updatePosition(event.data);
+            } else if (event.dataType === EventType.AbsoluteAttitude) {
+                this.updateAttitude(event.data);
+            }
+        });
+    }
+
+    updatePosition(position) {
+        if (!this.map) {
+            return;
+        }
+
+        if (!(position instanceof WGS84)) {
+            if (this.mapMarker) {
+                this.mapMarker.remove();
+                this.mapMarker = null;
+                this.positionIcon = null;
+            }
+            return;
+        }
+
+        const lngLat = [position.lng, position.lat];
+
+        if (!this.mapMarker) {
+            this.mapMarker = this.createPositionMarker(lngLat).addTo(this.map);
+            this.map.jumpTo({
+                center: lngLat,
+                zoom: this.props.defaultZoom
+            });
+        } else {
+            this.mapMarker.setLngLat(lngLat);
+        }
+    }
+
+    updateAttitude(attitude) {
+        if (!this.positionIcon) {
+            return;
+        }
+
+        if (!(attitude instanceof Attitude)) {
+            if (this.compassIcon) {
+                this.positionIcon.removeChild(this.compassIcon);
+            }
+            return;
+        }
+
+        if (!this.compassIcon) {
+            this.createCompassElement();
+        }
+
+        this.positionIcon.style.transform
+        = 'rotate(' + attitude.headingDegrees + 'deg)';
+    }
+
+    renderNetwork() {
+        if (!this.map) {
+            return;
+        }
+
+        const network = this.props.network;
+
+        if (network === this.previousNetwork) {
+            return;
+        }
+        this.previousNetwork = network;
+
+        if (!network) {
+            if (this.networkLayer) {
+                this.map.removeLayer(this.networkLayer);
+                this.networkLayer = null;
+            }
+            return;
+        }
+
+        const layer = {
+            id: 'network',
+            type: 'line',
+            source: {
+                type: 'geojson',
+                data: {
+                    type: 'Feature',
+                    properties: {},
+                    geometry: {
+                        type: 'MultiLineString',
+                        coordinates: []
+                    }
+                }
+            },
+            paint: {
+                'line-color': '#0000FF',
+                'line-width': 3
+            }
+        };
+
+        for (let i = 0; i < network.edges.length; i++) {
+            layer.source.data.geometry.coordinates.push([
+                [network.edges[i].node1.coords.lng, network.edges[i].node1.coords.lat],
+                [network.edges[i].node2.coords.lng, network.edges[i].node2.coords.lat]
+            ]);
+        }
+
+        this.map.on('load', () => {
+            this.networkLayer = this.map.addLayer(layer);
+        });
+    }
+
+    render() {
+        this.renderNetwork();
+        return (
+            <div ref={map => (this.mapContainer = map)}
+                style={{ height: '300px' }} />
+        );
+    }
 }
 
 export default MapComponent;

package/debug/components/PdrComponent.jsx

@@ -29,47 +29,47 @@ class PdrComponent extends React.Component {
         this.pdrProvider.stop();
     }
 
-  onEvent = events => {
-      const newState = {};
-      events.forEach(event => {
-          if (event.dataType === EventType.AbsolutePosition) {
-              newState.position = event.data;
-          } else if (event.dataType === EventType.AbsoluteAttitude) {
-              newState.attitude = event.data;
-          }
-      });
-      if (!isEmpty(newState)) {
-          this.setState(newState);
-      }
+    onEvent = events => {
+        const newState = {};
+        events.forEach(event => {
+            if (event.dataType === EventType.AbsolutePosition) {
+                newState.position = event.data;
+            } else if (event.dataType === EventType.AbsoluteAttitude) {
+                newState.attitude = event.data;
+            }
+        });
+        if (!isEmpty(newState)) {
+            this.setState(newState);
+        }
 
-      if (this.map) {
-          this.map.parseEvents(events);
-      }
-  };
+        if (this.map) {
+            this.map.parseEvents(events);
+        }
+    };
 
-  onError = error => {
-      this.setState({
-          position: error,
-          attitude: error
-      });
-  };
+    onError = error => {
+        this.setState({
+            position: error,
+            attitude: error
+        });
+    };
 
-  render() {
-      const attitudeRender = Utils.renderAttitude(this.state.attitude);
-      const positionRender = Utils.renderPosition(this.state.position);
+    render() {
+        const attitudeRender = Utils.renderAttitude(this.state.attitude);
+        const positionRender = Utils.renderPosition(this.state.position);
 
-      return (
-          <div>
-              <h3>Position</h3>
-              {positionRender}
-              <h3>Attitude</h3>
-              {attitudeRender}
-              <h3>Map</h3>
-              <MapComponent ref={map => (this.map = map)}
-                  network={NavigationConfig.ITINERARY} />
-          </div>
-      );
-  }
+        return (
+            <div>
+                <h3>Position</h3>
+                {positionRender}
+                <h3>Attitude</h3>
+                {attitudeRender}
+                <h3>Map</h3>
+                <MapComponent ref={map => (this.map = map)}
+                    network={NavigationConfig.ITINERARY} />
+            </div>
+        );
+    }
 }
 
 export default PdrComponent;

package/debug/components/PositioningPoseComponent.jsx

@@ -13,105 +13,105 @@ import ProvidersLogger from '../../src/providers/ProvidersLogger';
 ProvidersLogger.enabled = true;
 
 class PositioningPoseComponent extends React.Component {
-  static propTypes = {positioningHandler: PropTypes.instanceOf(PositioningHandler).isRequired};
-
-  constructor(props, context) {
-      super(props, context);
-      this.state = {
-          position: null,
-          attitude: null,
-          errored: false
-      };
-  }
-
-  start() {
-      const output = this.props.positioningHandler.start(
-          [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
-          this.onEvents,
-          this.onError,
-          {
-              waitInputPosition: true,
-              useMapMatching: true
-          }
-      );
-
-      if (!output) {
-          return;
-      }
-
-      this.id = output.id;
-
-      this.props.positioningHandler.setItinerary(this.id, NavigationConfig.ITINERARY);
-      this.props.positioningHandler.setNetwork(this.id, NavigationConfig.ITINERARY);
-      this.props.positioningHandler.setPosition(this.id, NavigationConfig.INITIAL_POSITION);
-      this.props.positioningHandler.setHeading(this.id, NavigationConfig.INITIAL_HEADING);
-  }
-
-  stop() {
-      this.props.positioningHandler.stop(this.id);
-      this.setState({
-          position: null,
-          attitude: null,
-          errored: false
-      });
-  }
-
-  onEvents = events => {
-      const newState = {};
-      events.forEach(event => {
-          if (event.dataType === EventType.AbsolutePosition) {
-              newState.position = event.data;
-          } else if (event.dataType === EventType.AbsoluteAttitude) {
-              newState.attitude = event.data;
-          }
-      });
-      if (!isEmpty(newState)) {
-          this.setState(newState);
-      }
-
-      if (this.map) {
-          this.map.parseEvents(events);
-      }
-  };
-
-  onError = error => {
-      this.setState({
-          position: error,
-          attitude: error,
-          errored: true
-      });
-  };
-
-  render() {
-      const attitudeRender = Utils.renderAttitude(this.state.attitude);
-      const positionRender = Utils.renderPosition(this.state.position);
-
-      const itineraryRender = Utils.renderItineraryInfo(
-          this.state.position && !(this.state.position instanceof Error)
-              ? NavigationConfig.ITINERARY.getInfo(this.state.position)
-              : null
-      );
-
-      return (
-          <div>
-              <StartStopComponent
-                  onStart={() => this.start()}
-                  onStop={() => this.stop()}
-                  errored={this.state.errored}
-              />
-
-              <h3>Position</h3>
-              {positionRender}
-              <h3>Attitude</h3>
-              {attitudeRender}
-              <h3>Map</h3>
-              <MapComponent ref={map => (this.map = map)}
-                  network={NavigationConfig.ITINERARY} />
-              <h3>ItineraryInfo</h3>
-              {itineraryRender}
-          </div>
-      );
-  }
+    static propTypes = {positioningHandler: PropTypes.instanceOf(PositioningHandler).isRequired};
+
+    constructor(props, context) {
+        super(props, context);
+        this.state = {
+            position: null,
+            attitude: null,
+            errored: false
+        };
+    }
+
+    start() {
+        const output = this.props.positioningHandler.start(
+            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+            this.onEvents,
+            this.onError,
+            {
+                waitInputPosition: true,
+                useMapMatching: true
+            }
+        );
+
+        if (!output) {
+            return;
+        }
+
+        this.id = output.id;
+
+        this.props.positioningHandler.setItinerary(this.id, NavigationConfig.ITINERARY);
+        this.props.positioningHandler.setNetwork(this.id, NavigationConfig.ITINERARY);
+        this.props.positioningHandler.setPosition(this.id, NavigationConfig.INITIAL_POSITION);
+        this.props.positioningHandler.setHeading(this.id, NavigationConfig.INITIAL_HEADING);
+    }
+
+    stop() {
+        this.props.positioningHandler.stop(this.id);
+        this.setState({
+            position: null,
+            attitude: null,
+            errored: false
+        });
+    }
+
+    onEvents = events => {
+        const newState = {};
+        events.forEach(event => {
+            if (event.dataType === EventType.AbsolutePosition) {
+                newState.position = event.data;
+            } else if (event.dataType === EventType.AbsoluteAttitude) {
+                newState.attitude = event.data;
+            }
+        });
+        if (!isEmpty(newState)) {
+            this.setState(newState);
+        }
+
+        if (this.map) {
+            this.map.parseEvents(events);
+        }
+    };
+
+    onError = error => {
+        this.setState({
+            position: error,
+            attitude: error,
+            errored: true
+        });
+    };
+
+    render() {
+        const attitudeRender = Utils.renderAttitude(this.state.attitude);
+        const positionRender = Utils.renderPosition(this.state.position);
+
+        const itineraryRender = Utils.renderItineraryInfo(
+            this.state.position && !(this.state.position instanceof Error)
+                ? NavigationConfig.ITINERARY.getInfo(this.state.position)
+                : null
+        );
+
+        return (
+            <div>
+                <StartStopComponent
+                    onStart={() => this.start()}
+                    onStop={() => this.stop()}
+                    errored={this.state.errored}
+                />
+
+                <h3>Position</h3>
+                {positionRender}
+                <h3>Attitude</h3>
+                {attitudeRender}
+                <h3>Map</h3>
+                <MapComponent ref={map => (this.map = map)}
+                    network={NavigationConfig.ITINERARY} />
+                <h3>ItineraryInfo</h3>
+                {itineraryRender}
+            </div>
+        );
+    }
 }
 
 export default PositioningPoseComponent;

package/package.json

@@ -12,7 +12,7 @@
     "@wemap/graph": "^2.7.9",
     "@wemap/logger": "^2.7.7",
     "@wemap/maths": "^2.7.7",
-    "@wemap/osm": "^2.7.9",
+    "@wemap/osm": "^2.7.11",
     "@wemap/utils": "^2.7.7",
     "geomagnetism": "^0.1.0",
     "lodash.isempty": "^4.4.0",
@@ -60,6 +60,6 @@
     "lint": "eslint --ext .js,.jsx --quiet src",
     "test": "mocha -r esm \"src/**/*.spec.js\""
   },
-  "version": "2.7.9",
-  "gitHead": "a43db34e902c6c4d34051444bb385b82add08068"
+  "version": "2.7.11",
+  "gitHead": "933f7fe5b16feed45fb06f9501981b1119b2c7af"
 }

package/src/events/EventType.js

@@ -16,6 +16,7 @@ export default {
     WifiSignals: 'WIFI_SIGNALS',
     ScanId: 'SCAN_ID',
     Barcode: 'BARCODE',
+    ProjectionMatrix: 'PROJECTION_MATRIX',
     Itinerary: 'ITINERARY',
     Network: 'NETWORK'
 };

package/src/providers/pose/ArCoreProvider.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-bitwise */
 import { Attitude } from '@wemap/geo';
 
 import Provider from '../Provider';
@@ -6,6 +7,26 @@ import MissingArCoreError from '../../errors/MissingArCoreError';
 import MissingNativeInterfaceError from '../../errors/MissingNativeInterfaceError';
 import Availability from '../../events/Availability';
 
+
+const Payload = {
+    Pose: {
+        ref: 2 ** 0,
+        size: 7
+    },
+    Barcode: {
+        ref: 2 ** 1,
+        size: 1
+    },
+    ProjMat: {
+        ref: 2 ** 2,
+        size: 16
+    },
+    ImageRef: {
+        ref: 2 ** 3,
+        size: 1
+    }
+};
+
 /**
  * Pose provider is the provider used by the PositioningHandler. It uses the best fusion
  * of what he can and provides an AbsoluteAttitude and an AbsolutePosition as an output.
@@ -67,7 +88,7 @@ class ArCoreProvider extends Provider {
         }
 
         const payload = JSON.parse(ArCoreProvider.nativeProvider.getInfo());
-        if (payload.length !== 0) {
+        if (payload.length > 1) {
             this.parsePayload(payload);
         }
         requestAnimationFrame(this.pullDataLoop);
@@ -75,17 +96,28 @@ class ArCoreProvider extends Provider {
 
     parsePayload(payload) {
 
+        const ref = payload[0];
+        let bufferIndex = 1;
+
         const events = [];
 
-        if (payload[0] !== null) {
-            const attitude = new Attitude(payload.slice(0, 4));
-            const position = payload.slice(4, 7);
+        if (ref & Payload.Pose.ref) {
+            const attitude = new Attitude(payload.slice(bufferIndex, bufferIndex + 4));
+            const position = payload.slice(bufferIndex + 4, bufferIndex + 7);
             events.push(this.createEvent(EventType.RelativeAttitude, attitude));
             events.push(this.createEvent(EventType.RelativePosition, position));
+            bufferIndex += Payload.Pose.size;
         }
-        const barcode = payload[7];
-        if (barcode !== null) {
-            events.push(this.createEvent(EventType.Barcode, barcode));
+
+        if (ref & Payload.Barcode.ref) {
+            events.push(this.createEvent(EventType.Barcode, payload[bufferIndex]));
+            bufferIndex += Payload.Barcode.size;
+        }
+
+        if (ref & Payload.ProjMat.ref) {
+            const projMatrix = payload.slice(bufferIndex, bufferIndex + Payload.ProjMat.size);
+            events.push(this.createEvent(EventType.ProjectionMatrix, projMatrix));
+            bufferIndex += Payload.ProjMat.size;
         }
 
         if (events.length !== 0) {