Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.axeda.esrs.sdk
Class AxedaSDKManager

    java.lang.Object
      com.axeda.esrs.sdk.AxedaSDKManager

    public class AxedaSDKManager

extends java.lang.Object

AxedaSDKManager: Provides access to Axeda functionality for which there is no standard SDK implementation. User: kholbrook Date: Apr 16, 2009 Time: 3:36:17 PM

Nested Class Summary
`class` | `AxedaSDKManager.SDKEndRemoteSessionAuditMessage`

Method Summary
`void` | `acknowledgeAlarm(long alarm_id)` Acknowledge the specified alarm
`void` | `acknowledgeAlarms(long[] ids)` Acknowledge the list of Alarm IDs which are passed in
`void` | `addDevicesToWatchList(long[] device_ids)` Add the specified dveice ID to the device watchlist of the User within whose context this call is made
`void` | `addDeviceToWatchList(long device_id)` Add the specified device ID to the device watchlist of the User within whose context this call is made
`void` | `associateGASServersWithDevice(Identifier deviceId, java.util.List<java.lang.String> selectedServers, boolean useExternalGASHostname)` Iterate through the host value of the servers passed in, and associate the supplied device with each server
`static Identifier[]` | `convertToIdentifierArray(long[] ids)` Convert the list of longs to an array of Axeda Identifier objects which can be used with the underlying Axeda APIs.
`protected void` | `createAlarm(com.axeda.drm.sdk.device.Device device, java.lang.String alarmName, int severity)` Overload for backwards compatibility, defaults "isFromUser" to true
`protected void` | `createAlarm(com.axeda.drm.sdk.device.Device device, java.lang.String alarmName, java.lang.String description, int severity, boolean isFromUser)` Create the named alarm for the specified model
`void` | `createAndSendNotification(java.lang.String notificationName, java.util.List<java.lang.String> emails, Identifier deviceId, boolean isFromUser)` Sends the named notification to the supplied list of email addresses, within the scope of the specified device
`void` | `createAuditMessage(java.lang.String message, com.axeda.drm.sdk.device.Device device, boolean isFromUser)` Creates a message in the Audit log with the specified text for the given device
`DecoratedRemoteSession` | `createRemoteSession(com.axeda.drm.sdk.device.Device device, java.lang.String interfaceName, java.lang.String description)` Overload to support backward compatibility
`DecoratedRemoteSession` | `createRemoteSession(com.axeda.drm.sdk.device.Device device, java.lang.String interfaceName, java.lang.String description, boolean useDeviceAssociatedRemoteServers)` Creates a remote session without specifying the secure attribute
`DecoratedRemoteSession` | `createRemoteSession(com.axeda.drm.sdk.device.Device device, java.lang.String interfaceName, java.lang.String description, boolean useDeviceAssociatedRemoteServers, boolean secure, boolean useExternalGASHostname)` Create Remote Session for the specified device and remote interface
`protected boolean` | `doesAlarmExist(com.axeda.drm.sdk.device.Model model, java.lang.String alarmName)` Utility method to see if this alarm exists in the database
`protected com.axeda.drm.services.device.ModelAlarm` | `findAlarm(com.axeda.drm.sdk.device.Model model, java.lang.String alarmName)` Utility method to load the alarm if it alarm exists in the database
`com.axeda.drm.sdk.device.Device` | `findDeviceById(long id)` Return the SDK Device object which in represetned by the String identifier which is passed in
`java.util.List<com.axeda.drm.sdk.device.Device>` | `findDevicesById(java.util.List<java.lang.String> ids)` Return the SDK Device objects which are represetned by the String identifiers which are passed in
`java.lang.String` | `getBandwidthTestURI()` Returns the URI which will be appended to the GAS server hostname to check for latency
`Context` | `getContext()` Returns a copy of the context in use within this class
`java.util.HashMap<java.lang.String,java.lang.Boolean>` | `getDeviceGatewayConnStatus(long deviceId)` Returns the online/offline status between the selected device and it's managing gateways
`long[]` | `getDevicesInWatchList()` Return the list of device IDs from the user's watchlist
`boolean[]` | `getGASConfigurationOptions()` Executes a callback to the ESRS codebase to determine the configuration for remote sessions The two configuration options which are determined are: - Whether or not to use the secure URL for a remote session - Whether to use the external or internal hostname for GAS servers
`java.util.Map` | `getGatewayConnectivity(long deviceId, boolean isFromUser)` Provides a Map of gateways which manage the specified Device ID, with the Identifier of the gateway as the key and a Boolean to indicate online / offline status
`java.util.List<com.axeda.drm.sdk.device.Device>` | `getGateways(Identifier deviceId)` Returns the Map of gateways associated with the supplied device ID
`static AxedaSDKManager` | `getInstance()` Get an instance of the AxedaSDKManager.
`static AxedaSDKManager` | `getInstance(java.lang.String username)` Get an instance of the AxedaSDKManager.
`long` | `getLastDeployedSyncPackage(long deviceId)` Retrieves the timestamp of the most recently deployed Sync Software package, or zero if no packages were found
`java.util.List<com.axeda.drm.sdk.device.Device>` | `getManagedDevices(Identifier gatewayId)` Overload to default the isFromUser to true
`java.util.List<com.axeda.drm.sdk.device.Device>` | `getManagedDevices(Identifier gatewayId, boolean isFromUser)` Returns the List of devices associated with the with the supplied gateway ID
`java.util.List<com.axeda.drm.sdk.device.Device>` | `getPeerGateways(Identifier gatewayId, boolean isFromUser)` Returns the List of gateways associated with the same devices associated with the supplied gateway ID
`int[]` | `getPortFromString(java.lang.String portString, java.lang.String type)` Parses the port string supplied by the Enterprise to deterine what the particular ports necessary for the chosen application will be
`java.lang.String` | `getRemoteInterfaceConnectPortString(RemoteInterface ri)` Returns the Connection String for a given remote application, in the format C1234C2345L3456L4567
`java.lang.String` | `getRemoteInterfacePort(RemoteInterface ri)` Get the port for a Remote Interface
`RemoteAccessSessionStatus` | `getSessionStatus(java.lang.String sessionId)` Retrieve the current status for the specified remote session.
`boolean` | `hasSyncPackagePending(long deviceId)` Returns true if this device has a pending deployed package
`boolean` | `isAlarmAcknowledged(long id)` Determines if the specified alarm has been acknowledged
`java.util.List<java.lang.String>` | `listRemoteServerNames()` Provides a list of all the remote access server host names available inn the system This list contains only the EXT hostname, which is the externally facing hostname that is used by agents
`void` | `raiseAlarmForDevice(com.axeda.drm.sdk.device.Device device, java.lang.String alarmName)` Raise an alarm of the specified name on the enterprise for the specified device.
`void` | `raiseAlarmForDevice(com.axeda.drm.sdk.device.Device device, java.lang.String alarmName, boolean create, boolean processTriggers, int severity)` Overload for CreateAlarm for backwards compatibility, defaults isFromUser to true.
`void` | `raiseAlarmForDevice(com.axeda.drm.sdk.device.Device device, java.lang.String alarmName, java.lang.String description, boolean create, boolean processTriggers, int severity, boolean isFromUser)` Raise an alarm of the specified name on the enterprise for the specified device.
`void` | `removeDeviceFromWatchList(long device_id)` Remove a specific device from the user's watchlist
`void` | `removeDevicesFromWatchList(long[] device_ids)` Removed the specified list of devices from the user's watchlist
`void` | `setAgentDataItem(DataItem di, java.lang.String dataItemValue, com.axeda.drm.sdk.device.Device device)` Set a data item on the enterprise side, this will set a new DataItem value for the specified DataItem and device
`void` | `setDataItem(DataItem di, java.lang.String dataItemValue, com.axeda.drm.sdk.device.Device device, boolean sendToEnterprise)` Set a data item on the enterprise side, this will set a new DataItem value for the specified DataItem and device
`void` | `setEnterpriseDataItem(DataItem di, java.lang.String dataItemValue, com.axeda.drm.sdk.device.Device device)` Set a data item on the enterprise side, this will set a new DataItem value for the specified DataItem and device
`void` | `terminateSession(java.lang.String sessionId)` Terminates the specified session in a user context for the specified user

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Method Detail

### getInstance

    public static AxedaSDKManager getInstance()

  Get an instance of the AxedaSDKManager. This method will create the Context you need to run within. If you are running this from a unit test, use the constructor that allows you to pass in the Context.

  Returns:
    An instance of the AxedaSDKManager that will operate within the user constraints implied in the context

### getInstance

    public static AxedaSDKManager getInstance(java.lang.String username)
                                       throws AxedaSDKManagerException

  Get an instance of the AxedaSDKManager. This method will create the Context you need to run within. If you are running this from a unit test, use the constructor that allows you to pass in the Context.

  Parameters:
    `username` - The name of the user which will be used to create a context for this user
  Returns:
    An instance of the AxedaSDKManager that will operate within the user constraints implied in the context
  Throws:
    `AxedaSDKManagerException` - if the User cannot be found in the DB

### createAndSendNotification

    public void createAndSendNotification(java.lang.String notificationName,
                                          java.util.List<java.lang.String> emails,
                                          Identifier deviceId,
                                          boolean isFromUser)
                                   throws AxedaSDKManagerException

  Sends the named notification to the supplied list of email addresses, within the scope of the specified device

  Parameters:
    `notificationName` - The name of the notification. This MUST be a notification which already exists in the system.
    `emails` - The list of email addresses to send to.
    `deviceId` - The ID of the Device which the notification is related to
    `isFromUser` - If true, uses the User's context, if false uses the System context
  Throws:
    `AxedaSDKManagerException`

### getDeviceGatewayConnStatus

    public java.util.HashMap<java.lang.String,java.lang.Boolean> getDeviceGatewayConnStatus(long deviceId)
                                                                                     throws AxedaSDKManagerException

  Returns the online/offline status between the selected device and it's managing gateways

  Parameters:
    `deviceId` - The ID of the device for which to determine connectivity
  Returns:
    A MAP where the key is the Stroing representation of the Device ID, and the value is a Boolean where true = online, false = offline
  Throws:
    `AxedaSDKManagerException`

### addDeviceToWatchList

    public void addDeviceToWatchList(long device_id)
                              throws AxedaSDKManagerException

  Add the specified device ID to the device watchlist of the User within whose context this call is made

  Parameters:
    `device_id` - The ID of a valid device which is to be added to the current user's watch list
  Throws:
    `AxedaSDKManagerException` - If the device cannot be added to the watchlist, or if the device_id is < 0, which indicates a non-persisted device

### addDevicesToWatchList

    public void addDevicesToWatchList(long[] device_ids)
                               throws AxedaSDKManagerException

  Add the specified dveice ID to the device watchlist of the User within whose context this call is made

  Parameters:
    `device_ids` - The IDs of the valid devices which are to be added to the current user's watch list
  Throws:
    `AxedaSDKManagerException` - If the list of device_ids is of zero length

### getDevicesInWatchList

    public long[] getDevicesInWatchList()
                                 throws AxedaSDKManagerException

  Return the list of device IDs from the user's watchlist

  Returns:
    An array of device IDs
  Throws:
    `AxedaSDKManagerException` - If there is a null pointer or other exception thrown in the process of loading the devices

### removeDeviceFromWatchList

    public void removeDeviceFromWatchList(long device_id)
                                   throws AxedaSDKManagerException

  Remove a specific device from the user's watchlist

  Parameters:
    `device_id` - The id of the device to remove
  Throws:
    `AxedaSDKManagerException` - If the device_id was invalid, or if an exception was thrown in the remove method

### removeDevicesFromWatchList

    public void removeDevicesFromWatchList(long[] device_ids)
                                    throws AxedaSDKManagerException

  Removed the specified list of devices from the user's watchlist

  Parameters:
    `device_ids` - The list of ids to remove from the watchlist
  Throws:
    `AxedaSDKManagerException` - If the device_ids list is not valid, or is the is a problem removing the devices from the watchlist

### acknowledgeAlarm

    public void acknowledgeAlarm(long alarm_id)
                          throws AxedaSDKManagerException

  Acknowledge the specified alarm

  Parameters:
    `alarm_id` - The ID of the alarm to acknowledge
  Throws:
    `AxedaSDKManagerException` - If the alarm id is invalid, or if an exception was thrown in the acknowledge alarms code

### acknowledgeAlarms

    public void acknowledgeAlarms(long[] ids)
                           throws AxedaSDKManagerException

  Acknowledge the list of Alarm IDs which are passed in

  Parameters:
    `ids` - The list of Alarm IDs to acknowledge
  Throws:
    `AxedaSDKManagerException` - If the ids array is invalid, or if an exception is thrown in the underlying code

### isAlarmAcknowledged

    public boolean isAlarmAcknowledged(long id)
                                throws AxedaSDKManagerException

  Determines if the specified alarm has been acknowledged

  Parameters:
    `id` - The id of the alarm to check
  Returns:
    True is the alarm has been acknowledged, False if it is unacknowledged
  Throws:
    `AxedaSDKManagerException` - If the id is not valid, or if an exception occurred in the underlying code

### raiseAlarmForDevice

    public void raiseAlarmForDevice(com.axeda.drm.sdk.device.Device device,
                                    java.lang.String alarmName)
                             throws AxedaSDKManagerException

  Raise an alarm of the specified name on the enterprise for the specified device. If the Alarm does not exist for the specified device's model it will be created. All configured Alarm triggers will fire, and the Alarm severity will be 2.

  Parameters:
    `device` - The device for which the alarm is to be raised
    `alarmName` - The name of the alarm to (optionally create and) raise
  Throws:
    `AxedaSDKManagerException` - if the alarm does not exist and cannot be created

### raiseAlarmForDevice

    public void raiseAlarmForDevice(com.axeda.drm.sdk.device.Device device,
                                    java.lang.String alarmName,
                                    boolean create,
                                    boolean processTriggers,
                                    int severity)
                             throws AxedaSDKManagerException

  Overload for CreateAlarm for backwards compatibility, defaults isFromUser to true.

  Parameters:
    `device` - The device for which the alarm is to be raised
    `alarmName` - The name of the alarm to (optionally create and) raise
    `create` - If true, and the alarm does not exist for the specified device's model, create the alarm
    `processTriggers` - If True, any configured alarm rulees will be fired
    `severity` - Integer representing the severity level of the alarm
  Throws:
    `AxedaSDKManagerException` - if the alarm does not exist and cannot be created

### raiseAlarmForDevice

    public void raiseAlarmForDevice(com.axeda.drm.sdk.device.Device device,
                                    java.lang.String alarmName,
                                    java.lang.String description,
                                    boolean create,
                                    boolean processTriggers,
                                    int severity,
                                    boolean isFromUser)
                             throws AxedaSDKManagerException

  Raise an alarm of the specified name on the enterprise for the specified device. If the Alarm does not exist for the specified device's model it will be created if the "create" boolean is true.

  Parameters:
    `device` - The device for which the alarm is to be raised
    `alarmName` - The name of the alarm to (optionally create and) raise
    `description` - The description for the alarm to (optionally create and) raise
    `create` - If true, and the alarm does not exist for the specified device's model, create the alarm
    `processTriggers` - If True, any configured alarm rulees will be fired
    `severity` - Integer representing the severity level of the alarm
    `isFromUser` - If True the request is sources from a user and will use the
  Throws:
    `AxedaSDKManagerException` - if the alarm does not exist and cannot be created

### doesAlarmExist

    protected boolean doesAlarmExist(com.axeda.drm.sdk.device.Model model,
                                     java.lang.String alarmName)
                              throws AxedaSDKManagerException

  Utility method to see if this alarm exists in the database

  Parameters:
    `model` - The model to search for this alarm
    `alarmName` - The name of the alarm to search for
  Returns:
    True if the alarm exists, false otherwise
  Throws:
    `AxedaSDKManagerException` - If the model or alarmName are invalid, or an exception is raised in the code being called

### findAlarm

    protected com.axeda.drm.services.device.ModelAlarm findAlarm(com.axeda.drm.sdk.device.Model model,
                                                                 java.lang.String alarmName)
                                                          throws AxedaSDKManagerException

  Utility method to load the alarm if it alarm exists in the database

  Parameters:
    `model` - The model to search for this alarm
    `alarmName` - The name of the alarm to search for
  Returns:
    The alarm if it exist, null otherwise
  Throws:
    `AxedaSDKManagerException` - If the model or alarmname are invalid

### createAlarm

    protected void createAlarm(com.axeda.drm.sdk.device.Device device,
                               java.lang.String alarmName,
                               int severity)
                        throws AxedaSDKManagerException

  Overload for backwards compatibility, defaults "isFromUser" to true

  Parameters:
    `device` - The name of the Device to which to add this alarm
    `alarmName` - The name of the alarm to add
    `severity` - The severity of the alarm
  Throws:
    `AxedaSDKManagerException` - If the device or alarmName is invalid.

### createAlarm

    protected void createAlarm(com.axeda.drm.sdk.device.Device device,
                               java.lang.String alarmName,
                               java.lang.String description,
                               int severity,
                               boolean isFromUser)
                        throws AxedaSDKManagerException

  Create the named alarm for the specified model

  Parameters:
    `device` - The name of the Device to which to add this alarm
    `alarmName` - The name of the alarm to add
    `description` - The description for the alarm instance being created
    `severity` - The severity of the alarm
    `isFromUser` - True if the request is sourced from the user, false if it is from an agent
  Throws:
    `AxedaSDKManagerException` - If the device or alarmName is invalid.

### convertToIdentifierArray

    public static Identifier[] convertToIdentifierArray(long[] ids)

  Convert the list of longs to an array of Axeda Identifier objects which can be used with the underlying Axeda APIs.

  Parameters:
    `ids` - The list of long values which represent device IDs
  Returns:
    The same array, in the same order, but converted to Identifier objects

### findDeviceById

    public com.axeda.drm.sdk.device.Device findDeviceById(long id)
                                                   throws AxedaSDKManagerException

  Return the SDK Device object which in represetned by the String identifier which is passed in

  Parameters:
    `id` - long representation of the Device identifier
  Returns:
    An ArrayList of SDK Device objects in the same order as the incoming List
  Throws:
    `AxedaSDKManagerException` - If the device does not exist, or the list is invalid

### findDevicesById

    public java.util.List<com.axeda.drm.sdk.device.Device> findDevicesById(java.util.List<java.lang.String> ids)
                                                                    throws AxedaSDKManagerException

  Return the SDK Device objects which are represetned by the String identifiers which are passed in

  Parameters:
    `ids` - String representations of Device identifiers
  Returns:
    An ArrayList of SDK Device objects in the same order as the incoming List
  Throws:
    `AxedaSDKManagerException` - If the device does not exist, or the list is invalid

### terminateSession

    public void terminateSession(java.lang.String sessionId)
                          throws AxedaSDKManagerException

  Terminates the specified session in a user context for the specified user

  Parameters:
    `sessionId` - The ID of the session to terminate
  Throws:
    `AxedaSDKManagerException` - If the sessionId is invalid, or the session cannot be terminated for some reason

### createRemoteSession

    public DecoratedRemoteSession createRemoteSession(com.axeda.drm.sdk.device.Device device,
                                                      java.lang.String interfaceName,
                                                      java.lang.String description)
                                               throws AxedaSDKManagerException

  Overload to support backward compatibility

  Parameters:
    `device` - The Device to which to open a session
    `interfaceName` - The name of the remote interface to which to bind the session
    `description` - The description to store for the session.
  Returns:
    A valid DecoratedRemoteSession which can be used to connect to the specified device
  Throws:
    `AxedaSDKManagerException`

### createRemoteSession

    public DecoratedRemoteSession createRemoteSession(com.axeda.drm.sdk.device.Device device,
                                                      java.lang.String interfaceName,
                                                      java.lang.String description,
                                                      boolean useDeviceAssociatedRemoteServers)
                                               throws AxedaSDKManagerException

  Creates a remote session without specifying the secure attribute

  Parameters:
    `device` - The Device to which to open a session
    `interfaceName` - The name of the remote interface to which to bind the session
    `description` - The description to store for the session.
    `useDeviceAssociatedRemoteServers` - Determines whether or not to use the GAS servers which are associated with the device
  Returns:
    A valid DecoratedRemoteSession which can be used to connect to the specified device
  Throws:
    `AxedaSDKManagerException`

### createRemoteSession

    public DecoratedRemoteSession createRemoteSession(com.axeda.drm.sdk.device.Device device,
                                                      java.lang.String interfaceName,
                                                      java.lang.String description,
                                                      boolean useDeviceAssociatedRemoteServers,
                                                      boolean secure,
                                                      boolean useExternalGASHostname)
                                               throws AxedaSDKManagerException

  Create Remote Session for the specified device and remote interface

  Parameters:
    `device` - The Device to which to open a session
    `interfaceName` - The name of the remote interface to which to bind the session
    `description` - The description to store for the session.
    `useDeviceAssociatedRemoteServers` - Determines whether or not to use the GAS servers which are associated with the device
    `secure` - If true the remote session will use the secure remote session URL. If false, the session will use the non-secure URLs
    `useExternalGASHostname` - True if the remote session should use the GAS's external hostname to connect, false if it should use the internal hostname
  Returns:
    A valid DecoratedRemoteSession which can be used to connect to the specified device
  Throws:
    `AxedaSDKManagerException`

### getSessionStatus

    public RemoteAccessSessionStatus getSessionStatus(java.lang.String sessionId)
                                               throws AxedaSDKManagerException

  Retrieve the current status for the specified remote session.

  Parameters:
    `sessionId` -
  Returns:
    The status object which contains the status as well as all information related to the remote session.
  Throws:
    `AxedaSDKManagerException` - If the sesison is inavlid, or if an exception is raised in the code being called

### getRemoteInterfacePort

    public java.lang.String getRemoteInterfacePort(RemoteInterface ri)
                                            throws AxedaSDKManagerException

  Get the port for a Remote Interface

  Parameters:
    `ri` - The remote interface to report the port of
  Returns:
    A String which represents the port
  Throws:
    `AxedaSDKManagerException` - If the remote interface is invalid, or cannot be read

### getRemoteInterfaceConnectPortString

    public java.lang.String getRemoteInterfaceConnectPortString(RemoteInterface ri)
                                                         throws AxedaSDKManagerException

  Returns the Connection String for a given remote application, in the format C1234C2345L3456L4567

  Parameters:
    `ri` - The Remote Interface from which to read the conneection String
  Returns:
    The Connection String
  Throws:
    `AxedaSDKManagerException`

### setEnterpriseDataItem

    public void setEnterpriseDataItem(DataItem di,
                                      java.lang.String dataItemValue,
                                      com.axeda.drm.sdk.device.Device device)
                               throws AxedaSDKManagerException

  Set a data item on the enterprise side, this will set a new DataItem value for the specified DataItem and device

  Parameters:
    `di` - The DataItem to set a value for
    `dataItemValue` - The value to set for the DataItem
    `device` - The device to which the DataItemValue will be bound
  Throws:
    `AxedaSDKManagerException` - If the dataitem, device or value is invalid

### getPortFromString

    public int[] getPortFromString(java.lang.String portString,
                                   java.lang.String type)
                            throws AxedaSDKManagerException

  Parses the port string supplied by the Enterprise to deterine what the particular ports necessary for the chosen application will be

  Parameters:
    `portString` - The entire port string from Enterprise, i.e. C1234C2345L3456
    `type` - Either "C" for connect ports in the String, or "L" for listening ports
  Returns:
  Throws:
    `AxedaSDKManagerException`

### setAgentDataItem

    public void setAgentDataItem(DataItem di,
                                 java.lang.String dataItemValue,
                                 com.axeda.drm.sdk.device.Device device)
                          throws AxedaSDKManagerException

  Set a data item on the enterprise side, this will set a new DataItem value for the specified DataItem and device

  Parameters:
    `di` - The DataItem to set a value for
    `dataItemValue` - The value to set for the DataItem
    `device` - The device to which the DataItemValue will be bound
  Throws:
    `AxedaSDKManagerException` - If the dataitem, value of device is invalid

### setDataItem

    public void setDataItem(DataItem di,
                            java.lang.String dataItemValue,
                            com.axeda.drm.sdk.device.Device device,
                            boolean sendToEnterprise)
                     throws AxedaSDKManagerException

  Set a data item on the enterprise side, this will set a new DataItem value for the specified DataItem and device

  Parameters:
    `di` - The DataItem to set a value for
    `dataItemValue` - The value to set for the DataItem
    `device` - The device to which the DataItemValue will be bound
    `sendToEnterprise` - If true the data item will go to the enterprise, if false to the agent
  Throws:
    `AxedaSDKManagerException` - If the dataitem, value, or device is invalid

### getLastDeployedSyncPackage

    public long getLastDeployedSyncPackage(long deviceId)
                                    throws AxedaSDKManagerException

  Retrieves the timestamp of the most recently deployed Sync Software package, or zero if no packages were found

  Parameters:
    `deviceId` - The ID of the device to check for package deployment
  Returns:
    The timestamp of the last deployed package, expressed in UTC
  Throws:
    `AxedaSDKManagerException`

### hasSyncPackagePending

    public boolean hasSyncPackagePending(long deviceId)
                                  throws AxedaSDKManagerException

  Returns true if this device has a pending deployed package

  Parameters:
    `deviceId` - The ID of the device to search for the Deployed Package on
  Returns:
    The timestamp of the most recently posted pending package, or zero if none is found
  Throws:
    `AxedaSDKManagerException`

### getGatewayConnectivity

    public java.util.Map getGatewayConnectivity(long deviceId,
                                                boolean isFromUser)
                                         throws AxedaSDKManagerException

  Provides a Map of gateways which manage the specified Device ID, with the Identifier of the gateway as the key and a Boolean to indicate online / offline status

  Parameters:
    `deviceId` - The ID of the Device to check
    `isFromUser` - If True, the context will be created as a User context, is False the context will be a System context
  Returns:
    A Map of Gateway Identifiers as Keys, with a Boolean indicating online/offline status between that Gateway and the target Device
  Throws:
    `AxedaSDKManagerException`

### getGateways

    public java.util.List<com.axeda.drm.sdk.device.Device> getGateways(Identifier deviceId)
                                                                throws AxedaSDKManagerException

  Returns the Map of gateways associated with the supplied device ID

  Returns:
    The Map of gateways, where the key is the ID of the GW, and the value is the SDK Device object which represents the gateway
  Throws:
    `AxedaSDKManagerException`

### getPeerGateways

    public java.util.List<com.axeda.drm.sdk.device.Device> getPeerGateways(Identifier gatewayId,
                                                                           boolean isFromUser)
                                                                    throws AxedaSDKManagerException

  Returns the List of gateways associated with the same devices associated with the supplied gateway ID

  Parameters:
    `gatewayId` - The ID of the Gateway of which to find the peers
    `isFromUser` - True if the request is coming from a user context, false is the request is coming from an SDK call outside of a User session
  Returns:
    The List of gateway devices which manage devices currently managed by the supplied gateway ID
  Throws:
    `AxedaSDKManagerException`

### getManagedDevices

    public java.util.List<com.axeda.drm.sdk.device.Device> getManagedDevices(Identifier gatewayId)
                                                                      throws AxedaSDKManagerException

  Overload to default the isFromUser to true

  Parameters:
    `gatewayId` -
  Returns:
    A list of SDK Device objects which represent the Managed Devices for the supplied gateway
  Throws:
    `AxedaSDKManagerException`

### getManagedDevices

    public java.util.List<com.axeda.drm.sdk.device.Device> getManagedDevices(Identifier gatewayId,
                                                                             boolean isFromUser)
                                                                      throws AxedaSDKManagerException

  Returns the List of devices associated with the with the supplied gateway ID

  Returns:
    The List of devices which are managed by the supplied gateway
  Throws:
    `AxedaSDKManagerException`

### associateGASServersWithDevice

    public void associateGASServersWithDevice(Identifier deviceId,
                                              java.util.List<java.lang.String> selectedServers,
                                              boolean useExternalGASHostname)
                                       throws AxedaSDKManagerException

  Iterate through the host value of the servers passed in, and associate the supplied device with each server

  Parameters:
    `deviceId` - The ID of the device to which the selected GAS servers will be associated
    `selectedServers` - The list of GAS host names which were selected by the agent
  Throws:
    `AxedaSDKManagerException` - If the Id or List is sinvalid, or if an exception is raised deeper in the code

### listRemoteServerNames

    public java.util.List<java.lang.String> listRemoteServerNames()
                                                           throws AxedaSDKManagerException

  Provides a list of all the remote access server host names available inn the system This list contains only the EXT hostname, which is the externally facing hostname that is used by agents

  Returns:
    A List of Strings which represent the external hostnames of all the GAS servers configured for this enterprise environment
  Throws:
    `AxedaSDKManagerException` - If there is an error reading the list of server names

### getGASConfigurationOptions

    public boolean[] getGASConfigurationOptions()

  Executes a callback to the ESRS codebase to determine the configuration for remote sessions The two configuration options which are determined are: - Whether or not to use the secure URL for a remote session - Whether to use the external or internal hostname for GAS servers

  Returns:
    A boolean array where [0] is true if the remote access session should be run over SSL, and [1] is true if the GAS server's external hostname should be used

### getBandwidthTestURI

    public java.lang.String getBandwidthTestURI()

  Returns the URI which will be appended to the GAS server hostname to check for latency

  Returns:
    The URL from the CustomConfig.properties file property com.axeda.esrs.portal.remote.gas.image.url this method can't really throw any exceptions, so not encapsulating

### createAuditMessage

    public void createAuditMessage(java.lang.String message,
                                   com.axeda.drm.sdk.device.Device device,
                                   boolean isFromUser)

  Creates a message in the Audit log with the specified text for the given device

  Parameters:
    `message` - The text to output in the Audit log
    `device` - The Device to tie the audit message to
    `isFromUser` - If True, the user's context will be used, if False the System context will be used

### getContext

    public Context getContext()

  Returns a copy of the context in use within this class

  Returns:
    The context which has been created within the constructor of this class

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD