src/Tracking/TrackingGlue.cpp

   1 /*
   2 Copyright_License {
   3
   4   XCSoar Glide Computer - http://www.xcsoar.org/
   5   Copyright (C) 2000-2013 The XCSoar Project
   6   A detailed list of copyright holders can be found in the file "AUTHORS".
   7
   8   This program is free software; you can redistribute it and/or
   9   modify it under the terms of the GNU General Public License
  10   as published by the Free Software Foundation; either version 2
  11   of the License, or (at your option) any later version.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License
  19   along with this program; if not, write to the Free Software
  20   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21 }
  22 */
  23
  24 #include "TrackingGlue.hpp"
  25 #include "NMEA/MoreData.hpp"
  26 #include "NMEA/Derived.hpp"
  27 #include "Units/System.hpp"
  28 #include "Util/Macros.hpp"
  29
  30 #ifdef HAVE_LIVETRACK24
  31
  32 static LiveTrack24::VehicleType
  33 MapVehicleTypeToLifetrack24(TrackingSettings::VehicleType vt)
  34 {
  35   static constexpr LiveTrack24::VehicleType vehicleTypeMap[] = {
  36     LiveTrack24::VehicleType::GLIDER,
  37     LiveTrack24::VehicleType::PARAGLIDER,
  38     LiveTrack24::VehicleType::POWERED_AIRCRAFT,
  39     LiveTrack24::VehicleType::HOT_AIR_BALLOON
  40   };
  41
  42   unsigned vti = (unsigned) vt;
  43   if (vti >= ARRAY_SIZE(vehicleTypeMap))
  44     vti = 0;
  45
  46   return vehicleTypeMap[vti];
  47 }
  48
  49 #endif
  50
  51 TrackingGlue::TrackingGlue()
  52 #ifdef HAVE_LIVETRACK24
  53   :last_timestamp(0),
  54    flying(false)
  55 #endif
  56 {
  57   settings.SetDefaults();
  58 #ifdef HAVE_LIVETRACK24
  59   LiveTrack24::SetServer(settings.livetrack24.server);
  60 #endif
  61
  62 #ifdef HAVE_SKYLINES_TRACKING_HANDLER
  63   skylines.SetHandler(this);
  64 #endif
  65 }
  66
  67 #ifdef HAVE_LIVETRACK24
  68
  69 void
  70 TrackingGlue::StopAsync()
  71 {
  72   ScopeLock protect(mutex);
  73   StandbyThread::StopAsync();
  74 }
  75
  76 void
  77 TrackingGlue::WaitStopped()
  78 {
  79   ScopeLock protect(mutex);
  80   StandbyThread::WaitStopped();
  81 }
  82
  83 #endif
  84
  85 void
  86 TrackingGlue::SetSettings(const TrackingSettings &_settings)
  87 {
  88 #ifdef HAVE_SKYLINES_TRACKING
  89   skylines.SetSettings(_settings.skylines);
  90 #endif
  91
  92 #ifdef HAVE_LIVETRACK24
  93   if (_settings.livetrack24.server != settings.livetrack24.server ||
  94       _settings.livetrack24.username != settings.livetrack24.username ||
  95       _settings.livetrack24.password != settings.livetrack24.password) {
  96     /* wait for the current job to finish */
  97     LockWaitDone();
  98
  99     /* now it's safe to access these variables without a lock */
 100     settings = _settings;
 101     state.ResetSession();
 102     LiveTrack24::SetServer(_settings.livetrack24.server);
 103   } else {
 104     /* no fundamental setting changes; the write needs to be protected
 105        by the mutex, because another job may be running already */
 106     ScopeLock protect(mutex);
 107     settings = _settings;
 108   }
 109 #endif
 110 }
 111
 112 void
 113 TrackingGlue::OnTimer(const MoreData &basic, const DerivedInfo &calculated)
 114 {
 115 #ifdef HAVE_SKYLINES_TRACKING
 116   skylines.Tick(basic);
 117 #endif
 118
 119 #ifdef HAVE_LIVETRACK24
 120   if (!settings.livetrack24.enabled)
 121     /* disabled by configuration */
 122     /* note that we are allowed to read "settings" without locking the
 123        mutex, because the background thread never writes to this
 124        attribute */
 125     return;
 126
 127   if (!basic.time_available || !basic.location_available)
 128     /* can't track without a valid GPS fix */
 129     return;
 130
 131   if (!clock.CheckUpdate(settings.interval * 1000))
 132     /* later */
 133     return;
 134
 135   ScopeLock protect(mutex);
 136   if (IsBusy())
 137     /* still running, skip this submission */
 138     return;
 139
 140   date_time = basic.date_time_utc;
 141   if (!basic.date_available)
 142     /* use "today" if the GPS didn't provide a date */
 143     (BrokenDate &)date_time = BrokenDate::TodayUTC();
 144
 145   location = basic.location;
 146   /* XXX use nav_altitude? */
 147   altitude = basic.NavAltitudeAvailable() && positive(basic.nav_altitude)
 148     ? (unsigned)basic.nav_altitude
 149     : 0u;
 150   ground_speed = basic.ground_speed_available
 151     ? (unsigned)Units::ToUserUnit(basic.ground_speed, Unit::KILOMETER_PER_HOUR)
 152     : 0u;
 153   track = basic.track_available
 154     ? basic.track
 155     : Angle::Zero();
 156
 157   last_flying = flying;
 158   flying = calculated.flight.flying;
 159
 160   Trigger();
 161 #endif
 162 }
 163
 164 #ifdef HAVE_LIVETRACK24
 165
 166 void
 167 TrackingGlue::Tick()
 168 {
 169   if (!settings.livetrack24.enabled)
 170     /* settings have been cleared meanwhile, bail out */
 171     return;
 172
 173   unsigned tracking_interval = settings.interval;
 174   LiveTrack24Settings copy = this->settings.livetrack24;
 175
 176   mutex.Unlock();
 177
 178   if (!flying) {
 179     if (last_flying && state.HasSession()) {
 180       /* landing: end tracking session */
 181       LiveTrack24::EndTracking(state.session_id, state.packet_id);
 182       state.ResetSession();
 183       last_timestamp = 0;
 184     }
 185
 186     /* don't track if not flying */
 187     mutex.Lock();
 188     return;
 189   }
 190
 191   const int64_t current_timestamp = date_time.ToUnixTimeUTC();
 192
 193   if (state.HasSession() && current_timestamp + 60 < last_timestamp) {
 194     /* time warp: create a new session */
 195     LiveTrack24::EndTracking(state.session_id, state.packet_id);
 196     state.ResetSession();
 197   }
 198
 199   last_timestamp = current_timestamp;
 200
 201   if (!state.HasSession()) {
 202     LiveTrack24::UserID user_id = 0;
 203     if (!copy.username.empty() && !copy.password.empty())
 204       user_id = LiveTrack24::GetUserID(copy.username, copy.password);
 205
 206     if (user_id == 0) {
 207       copy.username.clear();
 208       copy.password.clear();
 209       state.session_id = LiveTrack24::GenerateSessionID();
 210     } else {
 211       state.session_id = LiveTrack24::GenerateSessionID(user_id);
 212     }
 213
 214     if (!LiveTrack24::StartTracking(state.session_id, copy.username,
 215                                     copy.password, tracking_interval,
 216                                     MapVehicleTypeToLifetrack24(settings.vehicleType))) {
 217       state.ResetSession();
 218       mutex.Lock();
 219       return;
 220     }
 221
 222     state.packet_id = 2;
 223   }
 224
 225   LiveTrack24::SendPosition(state.session_id, state.packet_id++,
 226                             location, altitude, ground_speed, track,
 227                             current_timestamp);
 228
 229   mutex.Lock();
 230 }
 231
 232 #endif
 233
 234 #ifdef HAVE_SKYLINES_TRACKING_HANDLER
 235
 236 void
 237 TrackingGlue::OnTraffic(uint32_t pilot_id, unsigned time_of_day_ms,
 238                         const GeoPoint &location, int altitude)
 239 {
 240   bool user_known;
 241
 242   {
 243     const ScopeLock protect(skylines_data.mutex);
 244     const SkyLinesTracking::Data::Traffic traffic(time_of_day_ms,
 245                                                   location, altitude);
 246     skylines_data.traffic[pilot_id] = traffic;
 247
 248     user_known = skylines_data.IsUserKnown(pilot_id);
 249   }
 250
 251   if (!user_known)
 252     /* we don't know this user's name yet - try to find it out by
 253        asking the server */
 254     skylines.RequestUserName(pilot_id);
 255 }
 256
 257 void
 258 TrackingGlue::OnUserName(uint32_t user_id, const TCHAR *name)
 259 {
 260   const ScopeLock protect(skylines_data.mutex);
 261   skylines_data.user_names[user_id] = name;
 262 }
 263
 264 #endif