private bool InitializePortalAPI()
{
try
{
PortalApiHelper.Init("Administrator", SecretManager.PortalPassword);
SecretManager.PortalPassword = string.IsNullOrEmpty(SecretManager.PortalPassword) ? SharedConstants.DEFAULT_PORTAL_PASSWORD : SecretManager.PortalPassword;
}
catch (Exception e)
{
DebugHelper.LogError($"The Portal API Access could not be initialized: {e.Message}");
//Attempting default password
if (SecretManager.PortalPassword != SharedConstants.DEFAULT_PORTAL_PASSWORD)
{
try
{
PortalApiHelper.Init("Administrator", SharedConstants.DEFAULT_PORTAL_PASSWORD);
SecretManager.PortalPassword = SharedConstants.DEFAULT_PORTAL_PASSWORD;
}
catch (Exception e2)
{
DebugHelper.LogCritical($"The Portal API Access could not be initialized: {e2.Message}");
DebugHelper.LogCritical($"Cannot access the Portal API. Please flash a new firmware.");
return(false);
}
}
}
return(true);
}
public async Task <ResultCommand> SetDeviceSecretKeys(RequestCommandSetDeviceSecretKeys requestSetDeviceKeys)
{
try
{
//Set new Portal password
if (!await PortalApiHelper.SetDevicePassword(SecretManager.PortalPassword, requestSetDeviceKeys.PortalPassword))
{
return(ResultCommand.CreateFailedCommand($"Error SetDevicePassword: Error while setting new device password."));
}
//Update Portal Password
SecretManager.PortalPassword = requestSetDeviceKeys.PortalPassword;
PortalApiHelper.Init("Administrator", SecretManager.PortalPassword);
//Change Encryption Key
SecretManager.EncryptionKey = requestSetDeviceKeys.EncryptionKey;
//Set new Access Point - Will change the AP after reboot of the app
//SecretManager.AccessPointSsid = SecretManager.AccessPointSsid;
SecretManager.AccessPointPassword = requestSetDeviceKeys.AccessPointPassword;
return(ResultCommand.CreateSuccessCommand());
}
catch (Exception e)
{
DebugHelper.LogError($"Error SetDevicePassword: {e.Message}.");
return(ResultCommand.CreateFailedCommand($"Error SetDevicePassword: {e.Message}."));
}
}
public async Task <ResultCommandAvailableNetworks> GetAvailableNetworkListHandler()
{
try
{
var wifiAdapterList = await WiFiAdapter.FindAllAdaptersAsync();
List <AvailableNetwork> networks = new List <AvailableNetwork>();
foreach (var adapter in wifiAdapterList)
{
try
{
var availableNetworks = await PortalApiHelper.GetAvailableNetworks(adapter.NetworkAdapter.NetworkAdapterId);
if (availableNetworks != null && availableNetworks.AvailableNetworks != null)
{
networks.AddRange(availableNetworks.AvailableNetworks);
}
}
catch (Exception) { }
}
var sortedNetworks = networks.OrderBy(x => x.SSID).Distinct().ToList();
return(new ResultCommandAvailableNetworks()
{
Networks = sortedNetworks, IsSuccess = true
});
}
catch (Exception e)
{
DebugHelper.LogError($"Error GetAvailableNetworkListHandler: {e.Message}.");
return(ResultCommand.CreateFailedCommand <ResultCommandAvailableNetworks>($"Error GetAvailableNetworkListHandler: {e.Message}."));
}
}
private async Task <IEnumerable <HeadlessApp> > LoadFirmwares()
{
var allFirmwares = await PortalApiHelper.ListFirmwares();
return(allFirmwares.AppPackages.Where(p =>
p.PackageFullName.ToLower().StartsWith("edison.devices.") &&
!p.PackageFullName.ToLower().StartsWith("edison.devices.onboarding")));
}
public async Task <ResultCommand> SetDeviceType(RequestCommandSetDeviceType requestDeviceType)
{
try
{
var apps = await LoadFirmwares();
//Find the app
var app = apps.FirstOrDefault(p => p.PackageFullName.ToLower().StartsWith(requestDeviceType.DeviceType.ToLower()));
if (app == null)
{
DebugHelper.LogError($"Package starting with {requestDeviceType.DeviceType} not found.");
return(ResultCommand.CreateFailedCommand($"Error SetDeviceType: Package starting with {requestDeviceType.DeviceType} not found."));
}
//Deactivate all other firmwares at startup
foreach (var appToStop in apps)
{
if (appToStop.IsStartup)
{
if (!await PortalApiHelper.SetStartupForHeadlessApp(false, appToStop.PackageFullName))
{
DebugHelper.LogError($"Error while turning off run at startup for App {appToStop.PackageFullName}");
}
}
if (!await PortalApiHelper.StopHeadlessApp(appToStop.PackageFullName))
{
DebugHelper.LogError($"Error while stopping App {appToStop.PackageFullName}");
}
}
//Start our firmware and set to run
if (!await PortalApiHelper.StartHeadlessApp(app.PackageFullName))
{
DebugHelper.LogError($"Error while starting App {app.PackageFullName}");
return(ResultCommand.CreateFailedCommand($"Error SetDeviceType: Error while starting App {app.PackageFullName}"));
}
if (!await PortalApiHelper.SetStartupForHeadlessApp(true, app.PackageFullName))
{
DebugHelper.LogError($"Error while turning on run at startup for App {app.PackageFullName}");
return(ResultCommand.CreateFailedCommand($"Error SetDeviceType: Error while turning on run at startup for App {app.PackageFullName}"));
}
return(ResultCommand.CreateSuccessCommand());
}
catch (Exception e)
{
DebugHelper.LogError($"Error SetDeviceType: {e.Message}.");
return(ResultCommand.CreateFailedCommand($"Error SetDeviceType: {e.Message}."));
}
}
public async Task <ResultCommand> StopApp(string appName)
{
var apps = await PortalApiHelper.ListFirmwares();
foreach (var app in apps.AppPackages)
{
if (app.PackageFullName.ToLower().StartsWith(appName.ToLower()))
{
if (!await PortalApiHelper.StopHeadlessApp(app.PackageFullName))
{
return(ResultCommand.CreateFailedCommand($"Error StopApp: Error while stopping App {app.PackageFullName}"));
}
break;
}
}
return(ResultCommand.CreateSuccessCommand());
}
public async Task <ResultCommandSoftAPSettings> GetAccessPointSettings()
{
try
{
var apSettings = await PortalApiHelper.GetSoftAPSettings();
return(new ResultCommandSoftAPSettings()
{
SoftAPSettings = apSettings,
IsSuccess = true
});
}
catch (Exception e)
{
DebugHelper.LogError($"Error GetAccessPointSettings: {e.Message}.");
return(ResultCommand.CreateFailedCommand <ResultCommandSoftAPSettings>($"Error GetAccessPointSettings: {e.Message}."));
}
}
public async Task <ResultCommandIPAdapters> GetNetworkProfiles()
{
try
{
var profiles = await PortalApiHelper.GetNetworkProfiles();
return(new ResultCommandIPAdapters()
{
IPAdapters = profiles,
IsSuccess = true
});
}
catch (Exception e)
{
DebugHelper.LogError($"Error GetAccessPointSettings: {e.Message}.");
return(ResultCommand.CreateFailedCommand <ResultCommandIPAdapters>($"Error GetAccessPointSettings: {e.Message}."));
}
}
public async Task <ResultCommand> SetDeviceName(RequestCommandSetDeviceName requestDeviceName)
{
try
{
if (!await PortalApiHelper.SetDeviceName(requestDeviceName.Name))
{
DebugHelper.LogError($"Error while setting device name: {requestDeviceName.Name}");
return(ResultCommand.CreateFailedCommand($"Error SetDeviceName: Error while setting device name: {requestDeviceName.Name}"));
}
return(ResultCommand.CreateSuccessCommand());
}
catch (Exception e)
{
DebugHelper.LogError($"Error SetDeviceName: {e.Message}.");
return(ResultCommand.CreateFailedCommand($"Error SetDeviceName: {e.Message}."));
}
}
public async Task <ResultCommandNetworkStatus> ConnectToNetworkHandler(RequestCommandConnectToNetwork requestConnectToNetwork)
{
try
{
NetworkInformation networkInfo = requestConnectToNetwork.NetworkInformation;
var wifiSet = await FindWifi(networkInfo.Ssid);
if (wifiSet != null)
{
if (!await PortalApiHelper.DisconnectFromNetwork(wifiSet.Adapter.NetworkAdapter.NetworkAdapterId))
{
DebugHelper.LogWarning($"Error while trying to disconnect from network: {wifiSet.Adapter.NetworkAdapter.NetworkAdapterId}");
}
var availableNetworks = await PortalApiHelper.GetAvailableNetworks(wifiSet.Adapter.NetworkAdapter.NetworkAdapterId);
foreach (var network in availableNetworks.AvailableNetworks)
{
if (network.ProfileAvailable && !await PortalApiHelper.DeleteNetworkProfile(wifiSet.Adapter.NetworkAdapter.NetworkAdapterId, network.ProfileName))
{
DebugHelper.LogWarning($"Error while trying to disconnect from network: {wifiSet.Adapter.NetworkAdapter.NetworkAdapterId}");
}
}
if (!await PortalApiHelper.ConnectToNetwork(wifiSet.Adapter.NetworkAdapter.NetworkAdapterId, networkInfo.Ssid, networkInfo.Password))
{
return(ResultCommand.CreateFailedCommand <ResultCommandNetworkStatus>($"Error ConnectToNetworkHandler: Could not connect to network '{networkInfo.Ssid}'."));
}
return(new ResultCommandNetworkStatus()
{
IsSuccess = true, Status = "Connected"
});
}
return(ResultCommand.CreateFailedCommand <ResultCommandNetworkStatus>($"Error ConnectToNetworkHandler: UnspecifiedFailure."));
}
catch (Exception e)
{
DebugHelper.LogError($"Error ConnectToNetworkHandler: {e.Message}.");
return(ResultCommand.CreateFailedCommand <ResultCommandNetworkStatus>($"Error ConnectToNetworkHandler: {e.Message}."));
}
}
