/// <summary>
/// Creates a new WIFIPLUG client without a API key or secret.
/// </summary>
public ApiClient()
{
_deviceOperations = new DeviceOperations(this);
_sessionOperations = new SessionOperations(this);
_userOperations = new UserOperations(this);
_groupOperations = new GroupOperations(this);
_eventOperations = new EventOperations(this);
}
/// <summary>
/// Creates a new WIFIPLUG client without a API key or secret.
/// </summary>
/// <param name="apiUrl">The custom base path of the API.</param>
public ApiClient(string apiUrl) : base(apiUrl)
{
_deviceOperations = new DeviceOperations(this);
_sessionOperations = new SessionOperations(this);
_userOperations = new UserOperations(this);
_groupOperations = new GroupOperations(this);
_eventOperations = new EventOperations(this);
}
public ManagementApiClient(string baseUri, TimeSpan?defaultTimeout = null)
{
var client = new ApiClient(new Uri(baseUri), defaultTimeout);
AgentVersions = new AgentVersionOperations(client);
AgentUploadInfo = new AgentUploadInfoOperations(client);
Applications = new ApplicationOperations(client);
ApplicationLogs = new ApplicationLogOperations(client);
ApplicationEnvironmentVariables = new ApplicationEnvironmentVariableOperations(client);
ApplicationVersions = new ApplicationVersionOperations(client);
ApplicationUpload = new ApplicationUploadInfoOperations(client);
Devices = new DeviceOperations(client);
DeviceConfiguration = new DeviceConfigurationOperations(client);
DeviceEnvironmentVariables = new DeviceEnvironmentVariableOperations(client);
DeviceTypes = new DeviceTypeOperations(client);
Health = new HealthOperations(client);
}
public void DeviceOperationsTest()
{
var deviceOperations = Substitute.For <IPersistedDeviceOperations>();
var cachingDeviceOperations = new DeviceOperations(deviceOperations);
cachingDeviceOperations.Remove("1");
deviceOperations.Get("1").Returns(TestDataCreator.Device("1", "2", "3", "4", "5", 1));
var device = cachingDeviceOperations.Get("1");
Assert.AreEqual("2", device.DeviceKey);
deviceOperations.Received().Get("1");
deviceOperations.ClearReceivedCalls();
var device2 = cachingDeviceOperations.Get("1");
Assert.AreEqual("2", device2.DeviceKey);
deviceOperations.DidNotReceive().Get("1");
}
private void OnOperationToDeviceWillComplete(IGarminDevice device, DeviceOperations operation)
{
m_TimeoutTimer.Stop();
if (m_CancelDialog != null)
{
m_CancelDialog.Close();
m_CancelDialog.Dispose();
m_CancelDialog = null;
}
}
private void OnOperationProgressed(IGarminDevice device, DeviceOperations operation, int progress)
{
}
private void OnBridgeWriteToDeviceCompleted(object sender, GarminFitnessCommunicatorBridge.TransferCompletedEventArgs e)
{
bool success = e.Success;
DeviceOperations lastOperation = m_CurrentOperation;
TriggerOperationWillCompleteEvent();
switch (m_CurrentOperation)
{
case DeviceOperations.WriteProfile:
{
Logger.Instance.LogText("Comm. : Profile written");
break;
}
case DeviceOperations.WriteWorkout:
{
Logger.Instance.LogText("Comm. : Workouts written");
break;
}
default:
{
Debug.Assert(false);
success = false;
break;
}
}
m_CurrentOperation = DeviceOperations.Idle;
if (WriteToDeviceCompleted != null)
{
WriteToDeviceCompleted(this, lastOperation, success, m_CancellationError);
}
}
public void ReadProfile(GarminFitnessPlugin.Data.GarminProfile profile)
{
Logger.Instance.LogText("Comm. : Reading profile");
Debug.Assert(m_CurrentOperation == DeviceOperations.Idle);
m_CancellationError = "";
m_Controller.CommunicatorBridge.SetDeviceNumber(m_DeviceNumber);
if (SupportsFITProfile)
{
Logger.Instance.LogText("Comm. : Reading FIT directory for profile");
m_MassStorageFileReadCount = 0;
m_IsReadingDirectory = true;
ClearTempDirectory();
m_CurrentOperation = DeviceOperations.ReadFITProfile;
m_Controller.CommunicatorBridge.GetFITDirectoryInfo();
}
else
{
m_CurrentOperation = DeviceOperations.ReadProfile;
m_Controller.CommunicatorBridge.ReadProfileFromFitnessDevice();
}
}
void OnBridgeReadDirectoryCompleted(object sender, GarminFitnessCommunicatorBridge.TransferCompletedEventArgs e)
{
bool operationComplete = true;
m_IsReadingDirectory = false;
if (e.Success)
{
if (OperationProgressed != null)
{
OperationProgressed(this, m_CurrentOperation, 0);
}
if (m_CurrentOperation == DeviceOperations.ReadMassStorageWorkouts)
{
m_MassStorageFilesToDownload = GetFilePaths(e.DataString);
Logger.Instance.LogText(String.Format("Comm. : Mass storage workout file count = {0}", m_MassStorageFilesToDownload.Count));
}
else if (m_CurrentOperation == DeviceOperations.ReadFITWorkouts)
{
List<String> fitFilesOnDevice = GetFilePaths(e.DataString);
m_MassStorageFilesToDownload = new List<String>();
foreach (string fitFile in fitFilesOnDevice)
{
if (fitFile.StartsWith(m_FITWorkoutFileReadPath) ||
fitFile.StartsWith(m_FITWorkoutSchedulesFileReadPath))
{
m_MassStorageFilesToDownload.Add(fitFile);
}
}
Logger.Instance.LogText(String.Format("Comm. : Workout file count = {0}", m_MassStorageFilesToDownload.Count));
}
else if (m_CurrentOperation == DeviceOperations.ReadFITProfile)
{
Logger.Instance.LogText("Comm. : Profile directory read");
List<String> fitFilesOnDevice = GetFilePaths(e.DataString);
m_MassStorageFilesToDownload = new List<String>();
foreach (string fitFile in fitFilesOnDevice)
{
if (fitFile.StartsWith(m_FITSettingsFileReadPath) ||
fitFile.StartsWith(m_FITSportFileReadPath))
{
m_MassStorageFilesToDownload.Add(fitFile);
}
}
Logger.Instance.LogText(String.Format("Comm. : Profile file count = {0}", m_MassStorageFilesToDownload.Count));
}
if (m_MassStorageFilesToDownload.Count > 0)
{
operationComplete = false;
m_Controller.CommunicatorBridge.GetBinaryFile(m_MassStorageFilesToDownload[0]);
}
}
if (operationComplete)
{
DeviceOperations lastOperation = m_CurrentOperation;
m_CurrentOperation = DeviceOperations.Idle;
if (ReadFromDeviceCompleted != null)
{
ReadFromDeviceCompleted(this, lastOperation, e.Success, m_CancellationError);
}
}
}
void OnBridgeExceptionTriggered(object sender, GarminFitnessCommunicatorBridge.ExceptionEventArgs e)
{
DeviceOperations lastOperation = m_CurrentOperation;
m_CancellationError = e.ExceptionText;
m_CurrentOperation = DeviceOperations.Idle;
Logger.Instance.LogText(String.Format("Bridge exception caught in device : {0}\nStack:{1}", m_CancellationError, new StackTrace(true).ToString()));
switch (lastOperation)
{
case DeviceOperations.ReadProfile:
case DeviceOperations.ReadWorkout:
{
if (ReadFromDeviceCompleted != null)
{
ReadFromDeviceCompleted(this, lastOperation, false, m_CancellationError);
}
break;
}
case DeviceOperations.WriteProfile:
case DeviceOperations.WriteWorkout:
{
if (WriteToDeviceCompleted != null)
{
WriteToDeviceCompleted(this, lastOperation, false, m_CancellationError);
}
break;
}
}
}
public void WriteWorkouts(List<IWorkout> workouts)
{
Logger.Instance.LogText("Comm. : Writing workouts");
Debug.Assert(m_CurrentOperation == DeviceOperations.Idle);
List<IWorkout> concreteWorkouts = new List<IWorkout>();
bool exportToFIT = false;
// Split workouts for the right export method
foreach (IWorkout currentWorkout in workouts)
{
if (currentWorkout.ContainsFITOnlyFeatures)
{
exportToFIT = true;
}
if (currentWorkout.GetSplitPartsCount() == 1)
{
concreteWorkouts.Add(currentWorkout);
}
else
{
List<WorkoutPart> parts = currentWorkout.SplitInSeperateParts();
foreach (WorkoutPart part in parts)
{
concreteWorkouts.Add(part);
}
}
}
m_CancellationError = "";
m_Controller.CommunicatorBridge.SetDeviceNumber(m_DeviceNumber);
if (!exportToFIT && !SupportsFITWorkouts && !SupportsWorkoutMassStorageTransfer)
{
// Basic TCX export
string fileName = "Default.tcx";
MemoryStream textStream = new MemoryStream();
if (concreteWorkouts.Count == 1)
{
fileName = Utils.GetWorkoutFilename(concreteWorkouts[0], GarminWorkoutManager.FileFormats.TCX);
}
WorkoutExporter.ExportWorkouts(concreteWorkouts, textStream);
m_CurrentOperation = DeviceOperations.WriteWorkout;
string xmlCode = Encoding.UTF8.GetString(textStream.GetBuffer());
m_Controller.CommunicatorBridge.WriteWorkoutsToFitnessDevice(xmlCode, fileName);
}
else
{
List<String> filenames = new List<String>();
string exportPath = String.Empty;
ClearTempDirectory();
if (exportToFIT || SupportsFITWorkouts)
{
// FIT export
if (SupportsFITWorkouts)
{
MemoryStream schedulesDataStream = new MemoryStream();
bool serializeDefiniton = true;
foreach (IWorkout currentWorkout in concreteWorkouts)
{
string fileName = Utils.GetWorkoutFilename(currentWorkout, GarminWorkoutManager.FileFormats.FIT);
FileStream fileStream = File.Create(m_TempDirectoryLocation + fileName);
// Serialize workout & schedules
WorkoutExporter.ExportWorkoutToFIT(currentWorkout, fileStream);
currentWorkout.SerializeToFITSchedule(schedulesDataStream, serializeDefiniton);
serializeDefiniton = false;
fileStream.Close();
filenames.Add(fileName);
Logger.Instance.LogText(String.Format("Export workout : {0}", fileName));
}
if (Options.Instance.EnableFITScheduling && schedulesDataStream.Length > 0)
{
FileStream schedulesFileStream = File.Create(m_TempDirectoryLocation + "\\" + "Schedules.fit");
WorkoutExporter.ExportSchedulesFITFile(schedulesFileStream, schedulesDataStream);
schedulesFileStream.Close();
filenames.Add("Schedules.fit");
Logger.Instance.LogText("Export schedules");
}
Debug.Assert(m_FITWorkoutFileWritePath.Equals(m_FITWorkoutSchedulesFileWritePath));
exportPath = m_FITWorkoutFileWritePath;
}
else
{
throw new NoDeviceSupportException(this, GarminFitnessView.GetLocalizedString("FITExportText"));
}
}
else
{
// Extended TCX export
if (SupportsWorkoutMassStorageTransfer)
{
foreach (IWorkout currentWorkout in concreteWorkouts)
{
string fileName = Utils.GetWorkoutFilename(currentWorkout, GarminWorkoutManager.FileFormats.TCX);
FileStream fileStream = File.Create(m_TempDirectoryLocation + fileName);
WorkoutExporter.ExportWorkout(currentWorkout, fileStream);
fileStream.Close();
filenames.Add(fileName);
Logger.Instance.LogText(String.Format("Export workout : {0}", fileName));
}
exportPath = m_WorkoutFileTransferPath;
}
else
{
throw new NoDeviceSupportException(this, GarminFitnessView.GetLocalizedString("NoMassStorageSupportText"));
}
}
m_CurrentOperation = DeviceOperations.WriteWorkout;
m_Controller.CommunicatorBridge.WriteFilesToDevice(filenames, exportPath);
}
}
public void WriteProfile(GarminFitnessPlugin.Data.GarminProfile profile)
{
Logger.Instance.LogText("Comm. : Writing profile");
Debug.Assert(m_CurrentOperation == DeviceOperations.Idle);
m_CancellationError = "";
m_Controller.CommunicatorBridge.SetDeviceNumber(m_DeviceNumber);
if (SupportsFITProfile)
{
if (m_FITSportFileWritePath.Equals(m_FITSettingsFileWritePath))
{
Logger.Instance.LogText("Comm. : Writing FIT profile");
IList<String> filenames;
ClearTempDirectory();
filenames = ProfileExporter.ExportProfileToFIT(m_TempDirectoryLocation);
Logger.Instance.LogText(String.Format("Comm. : {0} FIT profile files", filenames.Count));
m_CurrentOperation = DeviceOperations.WriteProfile;
m_Controller.CommunicatorBridge.WriteFilesToDevice(filenames, m_FITSportFileWritePath);
}
else
{
throw new Exception("Different export path for setting & sport FIT files. Please report this problem to PissedOffCil on the SportTracks forum.");
}
}
else
{
string fileName = "UserProfile.tcx";
MemoryStream textStream = new MemoryStream();
ProfileExporter.ExportProfile(profile, textStream);
string xmlCode = Encoding.UTF8.GetString(textStream.GetBuffer());
m_CurrentOperation = DeviceOperations.WriteProfile;
m_Controller.CommunicatorBridge.WriteProfileToFitnessDevice(xmlCode, fileName);
}
}
public void WriteProfile(string profileXml)
{
Logger.Instance.LogText("Comm. : Writing string profile");
Debug.Assert(m_CurrentOperation == DeviceOperations.Idle);
string fileName = "UserProfile.tcx";
m_CancellationError = "";
m_Controller.CommunicatorBridge.SetDeviceNumber(m_DeviceNumber);
m_CurrentOperation = DeviceOperations.WriteProfile;
m_Controller.CommunicatorBridge.WriteProfileToFitnessDevice(profileXml, fileName);
}
public void ReadWorkouts()
{
Logger.Instance.LogText("Comm. : Reading workouts");
Debug.Assert(m_CurrentOperation == DeviceOperations.Idle);
m_CancellationError = "";
m_Controller.CommunicatorBridge.SetDeviceNumber(m_DeviceNumber);
if (SupportsFITWorkouts ||
SupportsWorkoutMassStorageTransfer)
{
m_MassStorageFileReadCount = 0;
m_IsReadingDirectory = true;
ClearTempDirectory();
if (SupportsFITWorkouts)
{
m_CurrentOperation = DeviceOperations.ReadFITWorkouts;
m_Controller.CommunicatorBridge.GetFITDirectoryInfo();
}
else
{
m_CurrentOperation = DeviceOperations.ReadMassStorageWorkouts;
m_Controller.CommunicatorBridge.GetWorkoutFiles();
}
}
else
{
m_CurrentOperation = DeviceOperations.ReadWorkout;
m_Controller.CommunicatorBridge.ReadWorkoutsFromFitnessDevice();
}
}
private void OnWriteToDeviceCompleted(IGarminDevice device, DeviceOperations operation, Boolean succeeded, String failureMessage)
{
String errorText = String.Empty;
if (CurrentTask.Type == BasicTask.TaskTypes.ExportWorkout)
{
Logger.Instance.LogText("Completed export workouts");
Debug.Assert(operation == DeviceOperations.WriteWorkout);
if (!succeeded)
{
errorText = GarminFitnessView.GetLocalizedString("ExportWorkoutsErrorText");
if (!String.IsNullOrEmpty(failureMessage))
{
errorText += "\n\nReason :\n" + failureMessage;
}
}
}
else if (CurrentTask.Type == BasicTask.TaskTypes.ExportProfile)
{
Logger.Instance.LogText("Completed export profile");
Debug.Assert(operation == DeviceOperations.WriteProfile);
if (!succeeded)
{
errorText = GarminFitnessView.GetLocalizedString("ExportProfileErrorText");
if (!String.IsNullOrEmpty(failureMessage))
{
errorText += "\n\nReason :\n" + failureMessage;
}
}
}
CompleteCurrentTask(succeeded, errorText);
}
private void OnBridgeReadFromDeviceCompleted(object sender, GarminFitnessCommunicatorBridge.TransferCompletedEventArgs e)
{
bool success = e.Success;
bool operationCompleted = true;
DeviceOperations lastOperation = m_CurrentOperation;
switch(m_CurrentOperation)
{
case DeviceOperations.ReadProfile:
{
Logger.Instance.LogText("Comm. : Profile read");
TriggerOperationWillCompleteEvent();
if (success)
{
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(e.DataString));
success = ProfileImporter.ImportProfile(stream);
stream.Close();
}
break;
}
case DeviceOperations.ReadMassStorageWorkouts:
case DeviceOperations.ReadFITWorkouts:
case DeviceOperations.ReadFITProfile:
{
if (success)
{
if (m_CurrentOperation == DeviceOperations.ReadFITProfile)
{
Logger.Instance.LogText("Comm. : Mass storage profile read");
}
else
{
Logger.Instance.LogText("Comm. : Mass storage workout read");
}
++m_MassStorageFileReadCount;
if (OperationProgressed != null)
{
OperationProgressed(this, m_CurrentOperation, m_MassStorageFileReadCount);
}
if (m_MassStorageFilesToDownload != null)
{
Debug.Assert(m_MassStorageFilesToDownload.Count > 0);
Logger.Instance.LogText(String.Format("Mass storage files remaining = {0}", m_MassStorageFilesToDownload.Count));
if (m_MassStorageFilesToDownload.Count > 0)
{
String currentFilename = m_TempDirectoryLocation + m_MassStorageFilesToDownload[0].Replace('/', '\\');
String fileDirectory = currentFilename.Substring(0, currentFilename.LastIndexOf('\\'));
Directory.CreateDirectory(fileDirectory);
FileStream newFile = File.Create(currentFilename);
Byte[] decodedData = UUDecode(e.DataString);
newFile.Write(decodedData, 0, decodedData.Length);
newFile.Close();
m_MassStorageFilesToDownload.RemoveAt(0);
operationCompleted = false;
Logger.Instance.LogText(String.Format("Mass storage files remaining after delete = {0}", m_MassStorageFilesToDownload.Count));
if (m_MassStorageFilesToDownload.Count > 0)
{
m_Controller.CommunicatorBridge.GetBinaryFile(m_MassStorageFilesToDownload[0]);
}
else
{
TriggerOperationWillCompleteEvent();
if (m_CurrentOperation == DeviceOperations.ReadFITProfile)
{
success = ProfileImporter.AsyncImportDirectory(m_TempDirectoryLocation, this);
}
else
{
success = WorkoutImporter.AsyncImportDirectory(m_TempDirectoryLocation, this);
}
}
}
else
{
try
{
throw new Exception();
}
catch (Exception exception)
{
Logger.Instance.LogText("Caught empty mass storage list\n" + exception.StackTrace);
}
}
}
}
else
{
TriggerOperationWillCompleteEvent();
m_MassStorageFilesToDownload.Clear();
}
break;
}
case DeviceOperations.ReadWorkout:
{
Logger.Instance.LogText("Comm. : Workouts read");
TriggerOperationWillCompleteEvent();
if (success)
{
ImportWorkoutFileResult(e.DataString);
}
break;
}
default:
{
Debug.Assert(false);
success = false;
break;
}
}
if (operationCompleted)
{
m_CurrentOperation = DeviceOperations.Idle;
if (ReadFromDeviceCompleted != null)
{
ReadFromDeviceCompleted(this, lastOperation, success, m_CancellationError);
}
}
}
public void OnAsyncImportCompleted(bool success)
{
DeviceOperations lastOperation = m_CurrentOperation;
m_CurrentOperation = DeviceOperations.Idle;
if (ReadFromDeviceCompleted != null)
{
ReadFromDeviceCompleted(this, lastOperation, success, m_CancellationError);
}
}
