TskGeoTrackpointsUtil.java

Go to the documentation of this file.

/*
 * Sleuth Kit Data Model
 *
 * Copyright 2020 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.sleuthkit.datamodel.blackboardutils.attributes;

import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;
import org.sleuthkit.datamodel.BlackboardAttribute;
import org.sleuthkit.datamodel.blackboardutils.attributes.TskGeoTrackpointsUtil.GeoTrackPointList;
import org.sleuthkit.datamodel.blackboardutils.attributes.TskGeoTrackpointsUtil.GeoTrackPointList.GeoTrackPoint;

public final class TskGeoTrackpointsUtil implements BlackboardAttributeUtil<GeoTrackPointList> {

        @Override
        public BlackboardAttribute toAttribute(String moduleName, GeoTrackPointList value) {
                if (value == null) {
                        throw new IllegalArgumentException("toAttribute was passed a null list");
                }

                return new BlackboardAttribute(
                                BlackboardAttribute.ATTRIBUTE_TYPE.TSK_GEO_TRACKPOINTS,
                                moduleName,
                                toJSON(value));
        }

        @Override
        public GeoTrackPointList fromAttribute(BlackboardAttribute attribute) {
                if (attribute == null) {
                        throw new IllegalArgumentException("fromAttribute was passed a null attribute");
                }

                BlackboardAttribute.ATTRIBUTE_TYPE type = BlackboardAttribute.ATTRIBUTE_TYPE.fromID(attribute.getAttributeType().getTypeID());
                if (type != BlackboardAttribute.ATTRIBUTE_TYPE.TSK_GEO_TRACKPOINTS) {
                        throw new IllegalArgumentException(String.format("Invalid attribute of type %s passed to fromAttribute method. Attribute of type TSK_GEO_TRACKPOINTS is required", type.getDisplayName()));
                }

                return fromJSON(attribute.getValueString());
        }

        private static GeoTrackPointList fromJSON(String json) {
                if (json == null || json.isEmpty()) {
                        throw new IllegalArgumentException("fromJSON was passed a empty or null JSON string");
                }

                return (new Gson()).fromJson(json, GeoTrackPointList.class);
        }

        private static String toJSON(GeoTrackPointList trackPoints) {
                if (trackPoints == null) {
                        throw new IllegalArgumentException("toJSON was passed a null track points list");
                }

                Gson gson = new Gson();
                return gson.toJson(trackPoints);
        }

        public static class GeoTrackPointList implements Iterable<GeoTrackPointList.GeoTrackPoint> {

                private final List<GeoTrackPoint> pointList;

                public GeoTrackPointList() {
                        pointList = new ArrayList<>();
                }

                public void addPoint(GeoTrackPoint trackPoint) {
                        if (trackPoint == null) {
                                throw new IllegalArgumentException("addPoint was passed a null track point");
                        }

                        pointList.add(trackPoint);
                }

                @Override
                public Iterator<GeoTrackPoint> iterator() {
                        return pointList.iterator();
                }

                public boolean isEmpty() {
                        return pointList.isEmpty();
                }

                public Long getStartTime() {
                        List<GeoTrackPoint> orderedPoints = getTimeOrderedPoints();
                        if (orderedPoints != null) {
                                for (GeoTrackPoint point : orderedPoints) {
                                        if (point.getTimeStamp() != null) {
                                                return point.getTimeStamp();
                                        }
                                }
                        }
                        return null;
                }

                public Long getEndTime() {
                        List<GeoTrackPoint> orderedPoints = getTimeOrderedPoints();
                        if (orderedPoints != null) {
                                for (int index = orderedPoints.size() - 1; index >= 0; index--) {
                                        GeoTrackPoint point = orderedPoints.get(index);
                                        if (point.getTimeStamp() != null) {
                                                return point.getTimeStamp();
                                        }
                                }
                        }
                        return null;
                }

                private List<GeoTrackPoint> getTimeOrderedPoints() {
                        return pointList.stream().sorted().collect(Collectors.toCollection(ArrayList::new));
                }

                public final static class GeoTrackPoint extends TskGeoWaypointsUtil.GeoWaypointList.GeoWaypoint implements Comparable<GeoTrackPoint> {

                        @SerializedName("TSK_GEO_VELOCITY")
                        private final Double velocity;
                        @SerializedName("TSK_DISTANCE_FROM_HOMEPOINT")
                        private final Double distanceFromHomePoint;
                        @SerializedName("TSK_DISTANCE_TRAVELED")
                        private final Double distanceTraveled;
                        @SerializedName("TSK_DATETIME")
                        private final Long timestamp;

                        public GeoTrackPoint(Double latitude,
                                        Double longitude,
                                        Double altitude,
                                        String name,
                                        Double velocity,
                                        Double distanceFromHomePoint,
                                        Double distanceTraveled,
                                        Long timestamp) {
                                super(latitude, longitude, altitude, name);
                                this.velocity = velocity;
                                this.distanceFromHomePoint = distanceFromHomePoint;
                                this.distanceTraveled = distanceTraveled;
                                this.timestamp = timestamp;
                        }

                        public Double getVelocity() {
                                return velocity;
                        }

                        public Double getDistanceFromHomePoint() {
                                return distanceFromHomePoint;
                        }

                        public Double getDistanceTraveled() {
                                return distanceTraveled;
                        }

                        public Long getTimeStamp() {
                                return timestamp;
                        }

                        @Override
                        public int compareTo(GeoTrackPoint otherTP) {
                                Long otherTimeStamp = otherTP.getTimeStamp();

                                if (timestamp == null && otherTimeStamp != null) {
                                        return -1;
                                } else if (timestamp != null && otherTimeStamp == null) {
                                        return 1;
                                } else {
                                        return timestamp.compareTo(otherTP.getTimeStamp());
                                }
                        }
                }
        }
}