void Set(const TCHAR *_name, const DownloadStatus *_download_status,
bool _failed) {
name = _name;
TCHAR path[MAX_PATH];
LocalPath(path, name);
if (File::Exists(path)) {
FormatByteSize(size.buffer(), size.MAX_SIZE,
File::GetSize(path));
#ifdef HAVE_POSIX
FormatISO8601(last_modified.buffer(),
BrokenDateTime::FromUnixTimeUTC(File::GetLastModification(path)));
#else
// XXX implement
last_modified.clear();
#endif
} else {
size.clear();
last_modified.clear();
}
downloading = _download_status != NULL;
if (downloading)
download_status = *_download_status;
failed = _failed;
}
static void
LogString(const TCHAR *p)
{
TextWriter writer(OpenLog());
if (!writer.IsOpen())
return;
TCHAR time_buffer[32];
FormatISO8601(time_buffer, BrokenDateTime::NowUTC());
writer.FormatLine(_T("[%s] %s"), time_buffer, p);
}
static void
WritePhase(TextWriter &writer, Phase &phase)
{
JSON::ObjectWriter object(writer);
NarrowString<64> buffer;
FormatISO8601(buffer.buffer(), phase.start_datetime);
object.WriteElement("start_time", JSON::WriteString, buffer);
FormatISO8601(buffer.buffer(), phase.end_datetime);
object.WriteElement("end_time", JSON::WriteString, buffer);
object.WriteElement("type", JSON::WriteString,
FormatPhaseType(phase.phase_type));
object.WriteElement("duration", JSON::WriteInteger, (int)phase.duration);
object.WriteElement("circling_direction", JSON::WriteString,
FormatCirclingDirection(phase.circling_direction));
object.WriteElement("alt_diff", JSON::WriteInteger, (int)phase.alt_diff);
object.WriteElement("distance", JSON::WriteInteger, (int)phase.distance);
object.WriteElement("speed", JSON::WriteFixed, phase.GetSpeed());
object.WriteElement("vario", JSON::WriteFixed, phase.GetVario());
object.WriteElement("glide_rate", JSON::WriteFixed, phase.GetGlideRate());
}
static void
WriteEventAttributes(TextWriter &writer,
const BrokenDateTime &time, const GeoPoint &location)
{
JSON::ObjectWriter object(writer);
if (time.IsPlausible()) {
NarrowString<64> buffer;
FormatISO8601(buffer.buffer(), time);
object.WriteElement("time", JSON::WriteString, buffer);
}
if (location.IsValid())
JSON::WriteGeoPointAttributes(object, location);
}
static void
LogString(const char *p)
{
#ifdef ANDROID
__android_log_print(ANDROID_LOG_INFO, "XCSoar", "%s", p);
#elif defined(HAVE_POSIX) && !defined(NDEBUG)
fprintf(stderr, "%s\n", p);
#endif
TextWriter writer(OpenLog());
if (!writer.IsOpen())
return;
char time_buffer[32];
FormatISO8601(time_buffer, BrokenDateTime::NowUTC());
writer.FormatLine("[%s] %s", time_buffer, p);
}
// TODO code: Keep marker text for use in log file etc.
void
InputEvents::eventMarkLocation(const TCHAR *misc)
{
const NMEAInfo &basic = CommonInterface::Basic();
if (StringIsEqual(misc, _T("reset"))) {
ScopeSuspendAllThreads suspend;
way_points.EraseUserMarkers();
} else {
const auto location = GetVisibleLocation();
if (!location.IsValid())
return;
MarkLocation(location, basic.date_time_utc);
const WaypointFactory factory(WaypointOrigin::USER, terrain);
Waypoint wp = factory.Create(location);
factory.FallbackElevation(wp);
TCHAR name[64] = _T("Marker");
if (basic.date_time_utc.IsPlausible()) {
auto *p = name + StringLength(name);
*p++ = _T(' ' );
FormatISO8601(p, basic.date_time_utc);
}
wp.name = name;
wp.type = Waypoint::Type::MARKER;
SuspendAppendSaveWaypoint(std::move(wp));
if (CommonInterface::GetUISettings().sound.sound_modes_enabled)
PlayResource(_T("IDR_WAV_CLEAR"));
}
trigger_redraw();
}
static void
Run(DebugReplay &replay, OrderedTask &task, const GlidePolar &glide_polar)
{
Validity last_location_available;
last_location_available.Clear();
AircraftState last_as;
bool last_as_valid = false;
bool task_finished = false;
unsigned active_taskpoint_index(-1);
char time_buffer[32];
while (replay.Next()) {
const MoreData &basic = replay.Basic();
const DerivedInfo &calculated = replay.Calculated();
if (!basic.location_available) {
last_location_available.Clear();
continue;
}
const AircraftState current_as = ToAircraftState(basic, calculated);
if (!last_location_available) {
last_as = current_as;
last_as_valid = true;
last_location_available = basic.location_available;
continue;
}
if (!basic.location_available.Modified(last_location_available))
continue;
if (!last_as_valid) {
last_as = current_as;
last_as_valid = true;
last_location_available = basic.location_available;
continue;
}
task.Update(current_as, last_as, glide_polar);
task.UpdateIdle(current_as, glide_polar);
task.SetTaskAdvance().SetArmed(true);
if (task.GetActiveIndex() != active_taskpoint_index) {
active_taskpoint_index = task.GetActiveIndex();
FormatISO8601(time_buffer, basic.date_time_utc);
printf("%s active_taskpoint_index=%u\n",
time_buffer, active_taskpoint_index);
}
const TaskStats &task_stats = task.GetStats();
if (task_finished != task_stats.task_finished) {
task_finished = true;
FormatISO8601(time_buffer, basic.date_time_utc);
printf("%s task finished\n", time_buffer);
}
last_as = current_as;
last_as_valid = true;
}
const TaskStats &task_stats = task.GetStats();
printf("task_started=%d task_finished=%d\n",
task_stats.start.task_started,
task_stats.task_finished);
printf("task elapsed %ds\n", (int)task_stats.total.time_elapsed);
printf("task speed %1.2f kph\n",
double(task_stats.total.travelled.GetSpeed() * 3.6));
printf("travelled distance %1.3f km\n",
double(task_stats.total.travelled.GetDistance() / 1000));
printf("scored distance %1.3f km\n",
double(task_stats.distance_scored / 1000));
if (task_stats.total.time_elapsed > 0)
printf("scored speed %1.2f kph\n",
double(task_stats.distance_scored
/ task_stats.total.time_elapsed * 3.6));
}
