FtcEventLoop

java.lang.Object
- com.qualcomm.ftccommon.FtcEventLoopBase
- - com.qualcomm.ftccommon.FtcEventLoop

All Implemented Interfaces:

EventLoop
```
public class FtcEventLoop
extends FtcEventLoopBase
```
Main event loop to control the robot
Modify this class with your own code, or create your own event loop by implementing EventLoop.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class FtcEventLoop.DefaultUsbModuleAttachmentHandler

Nested Classes
Modifier and Type	Class and Description
`class`	`FtcEventLoop.DefaultUsbModuleAttachmentHandler`

Field Summary

Fields
Modifier and Type	Field and Description
`protected java.util.Set<java.lang.String>`	`attachedUsbDevices`
`protected java.lang.Object`	`attachedUsbDevicesLock`
`protected java.util.Map<SerialNumber,ControllerConfiguration>`	`deviceControllers`
`protected OpModeManagerImpl`	`opModeManager`
`protected java.util.concurrent.atomic.AtomicReference<OpMode>`	`opModeStopRequested`
`protected OpModeRegister`	`register`
`protected UsbModuleAttachmentHandler`	`usbModuleAttachmentHandler`
`protected USBScanManager`	`usbScanManager`
`protected Utility`	`utility`

Fields inherited from class com.qualcomm.ftccommon.FtcEventLoopBase
activityContext, ftcEventLoopHandler, networkConnectionHandler, programmingModeController, robotCfgFileMgr, runningOnDriverStation, TAG

Fields inherited from interface com.qualcomm.robotcore.eventloop.EventLoop
TELEMETRY_DEFAULT_INTERVAL

Constructor Summary

Constructors
Constructor and Description
`FtcEventLoop(HardwareFactory hardwareFactory, OpModeRegister register, UpdateUI.Callback callback, Activity activityContext, ProgrammingModeController programmingModeController)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected OpModeManagerImpl`	`createOpModeManager()`
`OpModeManagerImpl`	`getOpModeManager()` Returns the OpModeManager associated with this event loop
`protected java.lang.String`	`getSerialNumberOfUsbDevice(UsbDevice usbDevice)`
`UsbModuleAttachmentHandler`	`getUsbModuleAttachmentHandler()`
`protected void`	`handleCommandInitOpMode(java.lang.String extra)`
`protected void`	`handleCommandRequestOpModeList()` The driver station is requesting our opmode list.
`protected void`	`handleCommandRunOpMode(java.lang.String extra)`
`protected void`	`handleCommandScan(java.lang.String extra)`
`void`	`handleUsbModuleDetach(RobotUsbModule module)` Process the fact that a usb module has now become detached from the system.
`void`	`init(EventLoopManager eventLoopManager)` Init method
`void`	`loop()` Loop method, this will be called repeatedly while the robot is running.
`void`	`onUsbDeviceAttached(UsbDevice usbDevice)` Deal with the fact that a UsbDevice has recently attached to the system
`CallbackResult`	`processCommand(Command command)` If the driver station sends over a command, it will be routed to this method.
`void`	`processedRecentlyAttachedUsbDevices()` Process any usb devices that might have recently attached.
`void`	`refreshUserTelemetry(TelemetryMessage telemetry, double sInterval)` Update's the user portion of the driver station screen with the contents of the telemetry object here provided if a sufficiently long duration has passed since the last update.
`void`	`requestOpModeStop(OpMode opModeToStopIfActive)` Requests that an OpMode be stopped if it's the currently active one
`void`	`setUsbModuleAttachmentHandler(UsbModuleAttachmentHandler handler)`
`void`	`teardown()` Teardown method

Methods inherited from class com.qualcomm.ftccommon.FtcEventLoopBase
handleCommandActivateConfiguration, handleCommandDeleteConfiguration, handleCommandRequestActiveConfiguration, handleCommandRequestConfigurations, handleCommandRequestConfigurationTemplates, handleCommandRequestParticularConfiguration, handleCommandRestartRobot, handleCommandSaveConfiguration, handleCommandStartProgrammingMode, handleCommandStopProgrammingMode

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

- Field Detail
  - utility
```
protected Utility utility
```
  - usbScanManager
```
protected USBScanManager usbScanManager
```
  - opModeManager
```
protected OpModeManagerImpl opModeManager
```
  - register
```
protected OpModeRegister register
```
  - usbModuleAttachmentHandler
```
protected UsbModuleAttachmentHandler usbModuleAttachmentHandler
```
  - attachedUsbDevicesLock
```
protected final java.lang.Object attachedUsbDevicesLock
```
  - attachedUsbDevices
```
protected java.util.Set<java.lang.String> attachedUsbDevices
```
  - opModeStopRequested
```
protected java.util.concurrent.atomic.AtomicReference<OpMode> opModeStopRequested
```
  - deviceControllers
```
protected java.util.Map<SerialNumber,ControllerConfiguration> deviceControllers
```
- Constructor Detail
  - FtcEventLoop
```
public FtcEventLoop(HardwareFactory hardwareFactory,
            OpModeRegister register,
            UpdateUI.Callback callback,
            Activity activityContext,
            ProgrammingModeController programmingModeController)
```
- Method Detail
  - createOpModeManager
```
protected OpModeManagerImpl createOpModeManager()
```
  - getOpModeManager
```
public OpModeManagerImpl getOpModeManager()
```
    Description copied from interface: EventLoop
    
    Returns the OpModeManager associated with this event loop
    
    Returns:
    the OpModeManager associated with this event loop
  - getUsbModuleAttachmentHandler
```
public UsbModuleAttachmentHandler getUsbModuleAttachmentHandler()
```
  - setUsbModuleAttachmentHandler
```
public void setUsbModuleAttachmentHandler(UsbModuleAttachmentHandler handler)
```
  - init
```
public void init(EventLoopManager eventLoopManager)
          throws RobotCoreException,
                 java.lang.InterruptedException
```
    Init method
    This code will run when the robot first starts up. Place any initialization code in this method.
    It is important to save a copy of the event loop manager from this method, as that is how you'll get access to the gamepad.
    If an Exception is thrown then the event loop manager will not start the robot.
    Caller synchronizes: called on RobotSetupRunnable.run() thread
    
    Parameters:
    eventLoopManager - event loop manager that is responsible for this event loop
    
    Throws:
    
    RobotCoreException - if a RobotCoreException is thrown, it will be handled by the event loop manager. The manager will report that the robot failed to start.
    
    java.lang.InterruptedException
  - loop
```
public void loop()
          throws RobotCoreException
```
    Loop method, this will be called repeatedly while the robot is running.
    
    Throws:
    
    RobotCoreException - if a RobotCoreException is thrown, it will be handled by the event loop manager. The manager may decide to either stop processing this iteration of the loop, or it may decide to shut down the robot.
    See Also:
    Caller synchronizes: called on EventLoopRunnable.run() thread.
  - refreshUserTelemetry
```
public void refreshUserTelemetry(TelemetryMessage telemetry,
                        double sInterval)
```
    Description copied from interface: EventLoop
    
    Update's the user portion of the driver station screen with the contents of the telemetry object here provided if a sufficiently long duration has passed since the last update.
    
    Parameters:
    telemetry - the telemetry object to send
    sInterval - the required minimum interval. NaN indicates that a system default interval should be used.
  - teardown
```
public void teardown()
              throws RobotCoreException
```
    Teardown method
    This method will be called when the robot is being shut down. This method should stop the robot. There will be no more changes to write to the hardware after this method is called.
    If an exception is thrown, then the event loop manager will attempt to shut down the robot without the benefit of this method.
    
    Throws:
    
    RobotCoreException - if a RobotCoreException is thrown, it will be handled by the event loop manager. The manager will then attempt to shut down the robot without the benefit of the teardown method.
    See Also:
    Caller synchronizes: called on EventLoopRunnable.run() thread.
  - processCommand
```
public CallbackResult processCommand(Command command)
                              throws java.lang.InterruptedException,
                                     RobotCoreException
```
    If the driver station sends over a command, it will be routed to this method. You can choose what to do with this command, or you can just ignore it completely.
    Called on RecvRunnable.run() thread. Method is thread safem, non-interfering
    
    Specified by:
    
    processCommand in interface EventLoop
    
    Overrides:
    
    processCommand in class FtcEventLoopBase
    
    Parameters:
    command - command to process
    
    Throws:
    
    java.lang.InterruptedException
    
    RobotCoreException
  - handleCommandScan
```
protected void handleCommandScan(java.lang.String extra)
                          throws RobotCoreException,
                                 java.lang.InterruptedException
```
    Throws:
    
    RobotCoreException
    
    java.lang.InterruptedException
    See Also:
    FtcConfigurationActivity#doUSBScanAndUpdateUI()
  - handleCommandRequestOpModeList
```
protected void handleCommandRequestOpModeList()
```
    The driver station is requesting our opmode list. Build up an appropriately-delimited list and send it back to them. Also take this opportunity to forcibly refresh their error/warning state: the opmode list is only infrequently requested (so sending another datagram isn't a traffic burden) and it's requested just after a driver station reconnects after a disconnect (so doing the refresh now is probably an opportune thing to do).
  - handleCommandInitOpMode
```
protected void handleCommandInitOpMode(java.lang.String extra)
```
  - handleCommandRunOpMode
```
protected void handleCommandRunOpMode(java.lang.String extra)
```
  - requestOpModeStop
```
public void requestOpModeStop(OpMode opModeToStopIfActive)
```
    Description copied from interface: EventLoop
    
    Requests that an OpMode be stopped if it's the currently active one
    
    Parameters:
    opModeToStopIfActive - the OpMode to stop if it's currently active
  - onUsbDeviceAttached
```
public void onUsbDeviceAttached(UsbDevice usbDevice)
```
    Deal with the fact that a UsbDevice has recently attached to the system
    
    Parameters:
    usbDevice -
    See Also:
    EventLoop.processedRecentlyAttachedUsbDevices()
  - getSerialNumberOfUsbDevice
```
protected java.lang.String getSerialNumberOfUsbDevice(UsbDevice usbDevice)
```
  - processedRecentlyAttachedUsbDevices
```
public void processedRecentlyAttachedUsbDevices()
                                         throws RobotCoreException,
                                                java.lang.InterruptedException
```
    Process any usb devices that might have recently attached. Called on the event loop thread.
    
    Throws:
    
    RobotCoreException
    
    java.lang.InterruptedException
    See Also:
    EventLoop.handleUsbModuleDetach(RobotUsbModule), EventLoop.onUsbDeviceAttached(UsbDevice)
  - handleUsbModuleDetach
```
public void handleUsbModuleDetach(RobotUsbModule module)
                           throws RobotCoreException,
                                  java.lang.InterruptedException
```
    Description copied from interface: EventLoop
    
    Process the fact that a usb module has now become detached from the system. This is called on the EventLoop thread by the EventLoopManager; there is sufficient time and correct context to, e.g., fully disarm and 'pretend' the associated module.
    
    Throws:
    
    RobotCoreException
    
    java.lang.InterruptedException
    See Also:
    EventLoop.processedRecentlyAttachedUsbDevices()

Class FtcEventLoop

Nested Class Summary

Field Summary

Fields inherited from class com.qualcomm.ftccommon.FtcEventLoopBase

Fields inherited from interface com.qualcomm.robotcore.eventloop.EventLoop

Constructor Summary

Method Summary

Methods inherited from class com.qualcomm.ftccommon.FtcEventLoopBase

Methods inherited from class java.lang.Object

Field Detail

utility

usbScanManager

opModeManager

register

usbModuleAttachmentHandler

attachedUsbDevicesLock

attachedUsbDevices

opModeStopRequested

deviceControllers

Constructor Detail

FtcEventLoop

Method Detail

createOpModeManager

getOpModeManager

getUsbModuleAttachmentHandler

setUsbModuleAttachmentHandler

init

loop

refreshUserTelemetry

teardown

processCommand

handleCommandScan

handleCommandRequestOpModeList

handleCommandInitOpMode

handleCommandRunOpMode

requestOpModeStop

onUsbDeviceAttached

getSerialNumberOfUsbDevice

processedRecentlyAttachedUsbDevices

handleUsbModuleDetach