135 lines
3.8 KiB
Rust
135 lines
3.8 KiB
Rust
use anyhow::{Context, Result};
|
|
use chrono::DateTime;
|
|
use serde::Deserialize;
|
|
use std::fs::File;
|
|
use std::io::BufReader;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct ParsedLocationRecord {
|
|
pub timestamp: i64,
|
|
pub latitude: f64,
|
|
pub longitude: f64,
|
|
pub accuracy: Option<i32>,
|
|
pub activity: Option<String>,
|
|
pub activity_confidence: Option<i32>,
|
|
}
|
|
|
|
// Google Takeout Location History JSON structures
|
|
#[derive(Debug, Deserialize)]
|
|
struct LocationHistory {
|
|
locations: Vec<LocationPoint>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
struct LocationPoint {
|
|
timestamp_ms: Option<String>, // Older format
|
|
timestamp: Option<String>, // Newer format (ISO8601)
|
|
latitude_e7: Option<i64>,
|
|
longitude_e7: Option<i64>,
|
|
accuracy: Option<i32>,
|
|
activity: Option<Vec<ActivityRecord>>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct ActivityRecord {
|
|
activity: Vec<ActivityType>,
|
|
#[allow(dead_code)] // Part of JSON structure, may be used in future
|
|
timestamp_ms: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct ActivityType {
|
|
#[serde(rename = "type")]
|
|
activity_type: String,
|
|
confidence: i32,
|
|
}
|
|
|
|
pub fn parse_location_json(path: &str) -> Result<Vec<ParsedLocationRecord>> {
|
|
let file = File::open(path).context("Failed to open location JSON file")?;
|
|
let reader = BufReader::new(file);
|
|
|
|
let history: LocationHistory =
|
|
serde_json::from_reader(reader).context("Failed to parse location history JSON")?;
|
|
|
|
let mut records = Vec::new();
|
|
|
|
for point in history.locations {
|
|
// Parse timestamp (try both formats)
|
|
let timestamp = if let Some(ts_ms) = point.timestamp_ms {
|
|
// Milliseconds since epoch
|
|
ts_ms
|
|
.parse::<i64>()
|
|
.context("Failed to parse timestamp_ms")?
|
|
/ 1000
|
|
} else if let Some(ts_iso) = point.timestamp {
|
|
// ISO8601 format
|
|
DateTime::parse_from_rfc3339(&ts_iso)
|
|
.context("Failed to parse ISO8601 timestamp")?
|
|
.timestamp()
|
|
} else {
|
|
continue; // Skip points without timestamp
|
|
};
|
|
|
|
// Convert E7 format to decimal degrees
|
|
let latitude = point.latitude_e7.map(|e7| e7 as f64 / 10_000_000.0);
|
|
let longitude = point.longitude_e7.map(|e7| e7 as f64 / 10_000_000.0);
|
|
|
|
// Extract highest-confidence activity
|
|
let (activity, activity_confidence) = point
|
|
.activity
|
|
.as_ref()
|
|
.and_then(|activities| activities.first())
|
|
.and_then(|record| {
|
|
record
|
|
.activity
|
|
.iter()
|
|
.max_by_key(|a| a.confidence)
|
|
.map(|a| (a.activity_type.clone(), a.confidence))
|
|
})
|
|
.unzip();
|
|
|
|
if let (Some(lat), Some(lon)) = (latitude, longitude) {
|
|
records.push(ParsedLocationRecord {
|
|
timestamp,
|
|
latitude: lat,
|
|
longitude: lon,
|
|
accuracy: point.accuracy,
|
|
activity,
|
|
activity_confidence,
|
|
});
|
|
}
|
|
}
|
|
|
|
Ok(records)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_e7_conversion() {
|
|
let lat_e7 = 374228300_i64;
|
|
let lat = lat_e7 as f64 / 10_000_000.0;
|
|
assert!((lat - 37.42283).abs() < 0.00001);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_sample_json() {
|
|
let json = r#"{
|
|
"locations": [
|
|
{
|
|
"latitudeE7": 374228300,
|
|
"longitudeE7": -1221086100,
|
|
"accuracy": 20,
|
|
"timestampMs": "1692115200000"
|
|
}
|
|
]
|
|
}"#;
|
|
|
|
let history: LocationHistory = serde_json::from_str(json).unwrap();
|
|
assert_eq!(history.locations.len(), 1);
|
|
}
|
|
}
|