MediaPlayer (mhp-1.1.2 1.1 API)

java.lang.Object
- com.sun.tv.media.MediaController
- - com.sun.tv.media.MediaPlayer

All Implemented Interfaces:

EventListener, Clock, Controller, ControllerListener, Duration, GainChangeListener, MediaHandler, Player

Direct Known Subclasses:

Handler
```
public abstract class MediaPlayer
extends MediaController
implements Player, GainChangeListener
```
This class is a part of the porting layer implementation for JavaTV. MediaPlayer implements the bases of a javax.media.Player. It handles all the Player state transitions, event handling and management of any Controller under its control.

Field Summary

Fields
Modifier and Type	Field and Description
`protected Control[]`	`controls`
`static ColorModel`	`defaultColorModel`
`protected GainControl`	`gainControl`
`protected DataSource`	`source`
`protected static TimeBase`	`systemTimeBase`
`static String`	`VERSION`

Fields inherited from class com.sun.tv.media.MediaController
parent, state

Fields inherited from interface javax.media.Controller
LATENCY_UNKNOWN, Prefetched, Prefetching, Realized, Realizing, Started, Unrealized

Fields inherited from interface javax.media.Clock
RESET

Fields inherited from interface javax.media.Duration
DURATION_UNBOUNDED, DURATION_UNKNOWN

Constructor Summary

Constructors
Constructor and Description

MediaPlayer()
Constructs a MediaPlayer.

Constructors
Constructor and Description
`MediaPlayer()` Constructs a MediaPlayer.

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`abortPrefetch()` Called when the prefetch() is aborted, i.e.
`protected void`	`abortRealize()` Called when the realize() is aborted, i.e.
`void`	`addController(Controller newController)` Assume control of another Controller.
`void`	`addControls(Control[] newControls)` Add more controls to the player
`protected void`	`addNode(Controller node)` Add a MediaNode to the list of Controllers under this Player's management.
`protected void`	`addNode(Controller node, boolean optional)` Add a MediaNode to the list of Controllers under this Player's management.
`protected void`	`allocBuffers()` Called during prefetch to allocate any necessary buffers.
`protected abstract boolean`	`audioEnabled()` Return true if the player is currently playing media with an audio track.
`void`	`close()` Close the player to stop all threads to make * it "finalizable".
`protected void`	`completePrefetch()` Called as a last step to complete the prefetch call.
`protected void`	`completeRealize()` Called as a last step to complete the realize call.
`protected abstract boolean`	`connectNodes()` This is invoked from doRealize() after all the nodes created in createNode() is fully realized.
`protected void`	`createGainControl()` If the Player can play audio, a gain control adapter is created and the player is registered a listener for gain change events
`protected abstract boolean`	`createNodes()` This is invoked from doRealize() during the player realization stage.
`protected boolean`	`deviceBusy(MediaController mc)` Check the given controller to see if it's busy or not.
`protected void`	`doClose()` This is called when close() is invoked on the Player.
`protected void`	`doFailedPrefetch()` Called when prefetch fails.
`protected void`	`doFailedRealize()` Called when realize fails.
`protected boolean`	`doPrefetch()` The stub function to perform the steps to prefetch the controller.
`protected boolean`	`doRealize()` The stub function (invoked from realize()) to perform the steps to realize the player.
`protected void`	`doSetMediaTime(Time now)` Called from setMediaTime.
`protected float`	`doSetRate(float factor)` Called from setRate.
`protected void`	`doStart()` Invoked by start() or syncstart().
`protected void`	`doStop()` The stop() method calls doStop() so that subclasses can add additional behavior.
`protected void`	`flush()` This should trigger a flush to the data path.
`void`	`gainChange(GainChangeEvent gce)` Subclass should override this method to change the audio gain.
`Component`	`getControlPanelComponent()` Get the Component with the default user interface for controlling this player.
`Control[]`	`getControls()` Return the controls that have been added (atleast includes the playback control)
`Time`	`getDuration()` Get the duration of the media.
`GainControl`	`getGainControl()` Get the object for controlling audio gain.
`protected abstract TimeBase`	`getMasterTimeBase()` This should be implemented by the subclass.
`Vector`	`getNodeList()` Return the list of MediaControllers supported by this Player.
`protected DataSource`	`getSource()` Get the DataSource used by this player.
`Component`	`getVisualComponent()` Get the Component this player will output its visual media to.
`void`	`muteChange(boolean m)` Subclass should override this method to implement the mute behavior.
`protected void`	`processEvent(ControllerEvent evt)` Process one event from another Controller which we are listening to.
`void`	`removeController(Controller oldController)` Removes the controller from the list of controlled controllers and sets the controller to its default time base.
`protected void`	`removeNode(Controller node)` Remove a MediaNode from the list of Controllers under this Player's management.
`protected void`	`setMediaLength(long t)` Set the upper bound of the media time.
`void`	`setMediaTime(Time now)` Loops through the list of nodes and controllers maintained by this player and invoke setMediaTime on each of them.
`float`	`setRate(float rate)` Set the playback rate on the player.
`void`	`setSource(DataSource source)` Set the DataSource that provides the media for this player.
`void`	`setStopTime(Time t)` sets up the specified stop time for all controllers in the internal node list
`void`	`setTimeBase(TimeBase tb)` Assigns a timebase for the player.
`void`	`setVisualComponent(Component component, Rectangle bounds)` Set the Component this player will output its visual media to.
`protected void`	`slaveToMasterTimeBase(TimeBase tb)` Slave all the controllers to the master time base.
`void`	`start()` Start the Player as soon as possible.
`void`	`stop()` requests to stop the player by delegating to stop(String request) method.
`protected void`	`stop(String request)` stops the player.
`protected void`	`stopAtTime()` stops the player because of the specified stop time has passed.
`boolean`	`synchronousPrefetch()` Prefetch the player and block until it's been prefetched or if it fails.
`boolean`	`synchronousRealize()` Realize the player and block until it's been realized or if it fails.
`void`	`syncStart(Time tbt)` Start at the given time base time.
`protected void`	`updateDuration()` updates player's duration.
`protected abstract boolean`	`videoEnabled()` Return true if the player is currently playing media with a video track.

Methods inherited from class com.sun.tv.media.MediaController
addControllerListener, cleanup, controllerUpdate, deallocate, dispatchEvent, doDeallocate, getControl, getMediaClockTime, getMediaNanoseconds, getMediaTime, getRate, getStartLatency, getState, getStopTime, getSyncTime, getTargetState, getTimeBase, mapToTimeBase, prefetch, realize, removeControllerListener, sendEvent, setTargetState

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

Methods inherited from interface javax.media.Controller
addControllerListener, deallocate, getControl, getStartLatency, getState, getTargetState, prefetch, realize, removeControllerListener

Methods inherited from interface javax.media.Clock
getMediaNanoseconds, getMediaTime, getRate, getStopTime, getSyncTime, getTimeBase, mapToTimeBase

- Field Detail
  - VERSION
```
public static String VERSION
```
  - source
```
protected DataSource source
```
  - systemTimeBase
```
protected static TimeBase systemTimeBase
```
  - controls
```
protected Control[] controls
```
  - gainControl
```
protected GainControl gainControl
```
  - defaultColorModel
```
public static ColorModel defaultColorModel
```
- Constructor Detail
  - MediaPlayer
```
public MediaPlayer()
```
    Constructs a MediaPlayer. The contructor sets up the default color model, default toolkit, lists of events for different states of the player and a utility object used for synchronization among threads
- Method Detail
  - setSource
```
public void setSource(DataSource source)
               throws IOException,
                      IncompatibleSourceException
```
    Set the DataSource that provides the media for this player. MediaPlayer only supports PullDataSource by default. Subclasses can override this method to support other DataSources.
    
    Specified by:
    
    setSource in interface MediaHandler
    
    Parameters:
    source - of media for this player.
    
    Throws:
    
    IOException - thrown when an i/o error occurs in reading information from the data source.
    
    IncompatibleSourceException - thrown if the Player can't use this source.
  - getSource
```
protected DataSource getSource()
```
    Get the DataSource used by this player.
    
    Returns:
    the DataSource used by this player.
  - close
```
public final void close()
```
    Close the player to stop all threads to make * it "finalizable". i.e., it's ready to be garbage collected. This is a "final" method and cannot be overridden. Subclasses should override doClose() to implement specific behavior.
    
    Specified by:
    
    close in interface Controller
    
    Overrides:
    
    close in class MediaController
  - doClose
```
protected void doClose()
```
    This is called when close() is invoked on the Player. close() takes care of the general behavior before invoking doClose(). Subclasses should implement this only if it needs to do something specific to close the player.
    
    Overrides:
    
    doClose in class MediaController
  - setTimeBase
```
public void setTimeBase(TimeBase tb)
                 throws IncompatibleTimeBaseException
```
    Assigns a timebase for the player. If the MediaPlayer plays back audio, the timebase can be none other than the master timebase as returned by getMasterTimeBase(). This is to ensure that we won't set to a timebase the audio cannot handle at this point. If the playback is video only, the timebase can be set to any timebase desired.
    
    Specified by:
    
    setTimeBase in interface Clock
    
    Overrides:
    
    setTimeBase in class MediaController
    
    Parameters:
    tb - time base to be used by the Player.
    
    Throws:
    
    IncompatibleTimeBaseException - thrown when a time base other than the master time base is set when audio is enabled.
  - setMediaLength
```
protected void setMediaLength(long t)
```
    Set the upper bound of the media time.
    
    Overrides:
    
    setMediaLength in class MediaController
    
    Parameters:
    duration - the duration in nanoseconds.
  - getDuration
```
public Time getDuration()
```
    Get the duration of the media.
    
    Specified by:
    
    getDuration in interface Duration
    
    Overrides:
    
    getDuration in class MediaController
    
    Returns:
    the duration of the media.
  - updateDuration
```
protected void updateDuration()
```
    updates player's duration. The duration could be changed as a result of adding or removing managed controllers from the player
  - setStopTime
```
public void setStopTime(Time t)
```
    sets up the specified stop time for all controllers in the internal node list
    
    Specified by:
    
    setStopTime in interface Clock
    
    Overrides:
    
    setStopTime in class MediaController
    
    Parameters:
    t - stop time
  - setMediaTime
```
public final void setMediaTime(Time now)
```
    Loops through the list of nodes and controllers maintained by this player and invoke setMediaTime on each of them. This is a "final" method and cannot be overridden by subclasses.
    
    Specified by:
    
    setMediaTime in interface Clock
    
    Overrides:
    
    setMediaTime in class MediaController
    
    Parameters:
    now - the target media time.
  - doSetMediaTime
```
protected void doSetMediaTime(Time now)
```
    Called from setMediaTime. This is used for subclasses to add in their own behavior.
    
    Parameters:
    now - the target media time.
  - setVisualComponent
```
public void setVisualComponent(Component component,
                      Rectangle bounds)
```
    Set the Component this player will output its visual media to. If this player has no visual component (e.g. audio only) setVisualComponent() will be ignored. This is only a hint to the video renderer. A particular player implementation may ignore this method. Subclasses should override this method and do the right thing. But it should also call this method first to ensure that the restrictions on player methods are enforced.
    
    Parameters:
    component - the component the player will use for displaying.
    bounds - the bounding rect the player uses for displaying.
  - getVisualComponent
```
public Component getVisualComponent()
```
    Get the Component this player will output its visual media to. If this player has no visual component (e.g. audio only) getVisualComponent() will return null. Subclasses should override this method and return the visual component but call this method first to ensure that the restrictions on player methods are enforced.
    
    Specified by:
    
    getVisualComponent in interface Player
    
    Returns:
    the media display component.
  - getControlPanelComponent
```
public Component getControlPanelComponent()
```
    Get the Component with the default user interface for controlling this player. If this player has no default control panel null is returned. Subclasses should override this method and return the control panel component but call this method first to ensure that the restrictions on player methods are enforced.
    
    Specified by:
    
    getControlPanelComponent in interface Player
    
    Returns:
    the default control panel GUI.
  - getGainControl
```
public GainControl getGainControl()
```
    Get the object for controlling audio gain. Return null if this player does not have a GainControl (e.g. no audio).
    
    Specified by:
    
    getGainControl in interface Player
    
    Returns:
    the GainControl object for this player.
  - gainChange
```
public void gainChange(GainChangeEvent gce)
```
    Subclass should override this method to change the audio gain.
    
    Specified by:
    
    gainChange in interface GainChangeListener
    
    Parameters:
    gce - the GainChangeEvent specifying the new gain level to set to.
  - muteChange
```
public void muteChange(boolean m)
```
    Subclass should override this method to implement the mute behavior.
    
    Parameters:
    m - the boolean value: true muted, false unmuted.
  - addControls
```
public void addControls(Control[] newControls)
```
    Add more controls to the player
    
    Parameters:
    newControls - list of controls to add to the player.
  - getControls
```
public Control[] getControls()
```
    Return the controls that have been added (atleast includes the playback control)
    
    Specified by:
    
    getControls in interface Controller
    
    Overrides:
    
    getControls in class MediaController
    
    Returns:
    the list of controls supported by this player.
  - getNodeList
```
public final Vector getNodeList()
```
    Return the list of MediaControllers supported by this Player.
    
    Returns:
    a vector of the MediaControllers supported by this Player.
  - start
```
public final void start()
```
    Start the Player as soon as possible. Start attempts to transition the player into the started state. If the player has not been realized, or prefetched, then the equivalent of those actions will occur, and the appropriate events will be generated. If the implied realize or prefetch fail, a failure event will be generated and the Player will remain in one of the non-started states.
    This is a "final" method. Subclasses should override doStart() to implement its own specific behavior.
    
    Specified by:
    
    start in interface Player
  - syncStart
```
public final void syncStart(Time tbt)
```
    Start at the given time base time. This overrides Clock.syncStart() and obeys all its semantics.
    This is a "final" method. Subclasses should override doStart() to implement its own specific behavior.
    
    Specified by:
    
    syncStart in interface Clock
    
    Overrides:
    
    syncStart in class MediaController
    
    Parameters:
    tbt - the time base time to start the player.
  - doStart
```
protected void doStart()
```
    Invoked by start() or syncstart(). Called from a separate thread called TimedStart thread. subclasses can override this method to implement its specific behavior.
    
    Specified by:
    
    doStart in class MediaController
  - synchronousRealize
```
public final boolean synchronousRealize()
```
    Realize the player and block until it's been realized or if it fails.
    
    Returns:
    true if realize was completed and successful.
  - synchronousPrefetch
```
public final boolean synchronousPrefetch()
```
    Prefetch the player and block until it's been prefetched or if it fails.
    
    Returns:
    true if the prefetch is successful.
  - doStop
```
protected void doStop()
```
    The stop() method calls doStop() so that subclasses can add additional behavior.
    
    Overrides:
    
    doStop in class MediaController
  - stop
```
public final void stop()
```
    requests to stop the player by delegating to stop(String request) method. sends a StopByRequest event to all registered listener(s).
    
    Specified by:
    
    stop in interface Clock
    
    Overrides:
    
    stop in class MediaController
  - stopAtTime
```
protected void stopAtTime()
```
    stops the player because of the specified stop time has passed. sends a StopByTime event to all registered listener(s). resets the stop time for the player
    
    Overrides:
    
    stopAtTime in class MediaController
  - stop
```
protected void stop(String request)
```
    stops the player. If the current stse of the player is unrealized, realized or prefetched, the player will be moved to the same state. if the player is in realizing state, it will be moved to the realized state. If the player is in prefetching or started state, it will be moved to the prefetched state. All managed controllers will be stoped as well.
    
    Parameters:
    request - specifies the type of stop request. Possible types of the request are StopAtTime, StopByRequest, and restarting. Corresponding events notifying that player has been stoped are sent to all listeners.
  - addNode
```
protected final void addNode(Controller node)
```
    Add a MediaNode to the list of Controllers under this Player's management. This is a protected method use only by subclasses. Use addController() for public access.
  - addNode
```
protected final void addNode(Controller node,
           boolean optional)
```
    Add a MediaNode to the list of Controllers under this Player's management.
  - removeNode
```
protected final void removeNode(Controller node)
```
    Remove a MediaNode from the list of Controllers under this Player's management. This is a protected method use only by subclasses. Use removeController() for public access.
    
    Parameters:
    node - a controller removed from the list of nodes
  - addController
```
public final void addController(Controller newController)
                         throws IncompatibleTimeBaseException
```
    Assume control of another Controller. A Player can accept responsibility for controlling another Controller. Once a Controller has been added this Player will:
    - Slave the Controller to the Player's time-base.
    - Use the Controller in the Player's computation of start latency. The value the Player returns in its getStartLatency method is the larger of: getStartLatency before the Controller was added, or getStartLatency of the Controller.
    - Pass along, as is appropriate, events that the Controller generates.
    - Invoke all Controller methods on the Controller.
    - For all asynchronous methods (realize, prefetch) a completion event will not be generated until all added Controllers have generated completion events.
    Note: It is undefined what will happen if a Controller is under the control of a Player and any of the Controller's methods are called outside of the controlling Player.
    Specified by:
    
    addController in interface Player
    
    Parameters:
    newController - the Controller this Player will control.
    
    Throws:
    
    IncompatibleTimeBaseException - thrown if the new controller will not accept the player's timebase.
  - removeController
```
public final void removeController(Controller oldController)
```
    Removes the controller from the list of controlled controllers and sets the controller to its default time base.
    
    Specified by:
    
    removeController in interface Player
    
    Parameters:
    oldController - the Controller to stop controlling.
  - createNodes
```
protected abstract boolean createNodes()
```
    This is invoked from doRealize() during the player realization stage. See doRealize() for a detail description. Subclasses should implement this to construct the internals of the player. The method in the subclass should create all the nodes (Controllers) that it needs to assemble a Player, use addNode(node) to add them to the list maintained by the MediaPlayer. The nodes should not be connected at this point since they haven't been realized. The MediaPlayer's doRealize() call will be responsible for invoking realize() on each node, wait for their RealizeCompleteEvent. At that point, it will invoke connectNodes(). Only at that point should subclasses connect up the nodes.
    In addition, this method should also choose a master timebase to be used by this player. This should be returned on a getMasterTimeBase() call.
    It should return success/failure. A subsequent call to createNodes() after the first successful completion should just return true.
    
    Returns:
    true if successful; false if failed.
  - connectNodes
```
protected abstract boolean connectNodes()
```
    This is invoked from doRealize() after all the nodes created in createNode() is fully realized. At this point, subclasses should implement this method to connect up the nodes. It should return a boolean signifying success/failure.
    
    Returns:
    true if successful; false if failed.
  - audioEnabled
```
protected abstract boolean audioEnabled()
```
    Return true if the player is currently playing media with an audio track.
    
    Returns:
    true if the player is playing audio.
  - videoEnabled
```
protected abstract boolean videoEnabled()
```
    Return true if the player is currently playing media with a video track.
    
    Returns:
    true if the player is playing video.
  - getMasterTimeBase
```
protected abstract TimeBase getMasterTimeBase()
```
    This should be implemented by the subclass. The subclass method should return the master TimeBase -- the TimeBase that all other Controllers (nodes) slave to. Use SystemTimeBase if unsure.
    
    Returns:
    the master time base.
  - doRealize
```
protected boolean doRealize()
```
    The stub function (invoked from realize()) to perform the steps to realize the player. It performs the following:
    - invoke createNodes() to allow subclasses to create the internal nodes of a player;
    - call realize() on each node created from createNode();
    - wait for RealizeCompleteEvent from each node;
    - call connectNodes() to allow subclasses to connect up the nodes after they are realized.
    Subclasses are allowed to override doRealize(). But this should be done in caution. createNodes() and connectNodes() should have provided all the flexiblity needed without changing doRealize(). This is called from a separately running thread.
    Specified by:
    
    doRealize in class MediaController
    
    Returns:
    true if successful.
  - createGainControl
```
protected void createGainControl()
```
    If the Player can play audio, a gain control adapter is created and the player is registered a listener for gain change events
  - completeRealize
```
protected void completeRealize()
```
    Called as a last step to complete the realize call.
    
    Overrides:
    
    completeRealize in class MediaController
  - doFailedRealize
```
protected void doFailedRealize()
```
    Called when realize fails.
    
    Overrides:
    
    doFailedRealize in class MediaController
  - completePrefetch
```
protected void completePrefetch()
```
    Called as a last step to complete the prefetch call.
    
    Overrides:
    
    completePrefetch in class MediaController
  - doFailedPrefetch
```
protected void doFailedPrefetch()
```
    Called when prefetch fails.
    
    Overrides:
    
    doFailedPrefetch in class MediaController
  - abortRealize
```
protected final void abortRealize()
```
    Called when the realize() is aborted, i.e. deallocate() was called while realizing. Release all resources claimed previously by the realize() call.
    
    Specified by:
    
    abortRealize in class MediaController
  - allocBuffers
```
protected void allocBuffers()
```
    Called during prefetch to allocate any necessary buffers. Subclasses can override this to implement its specific requirements.
  - doPrefetch
```
protected boolean doPrefetch()
```
    The stub function to perform the steps to prefetch the controller. This will call prefetch() on every node in the node list and wait for their completion events. This is called from a separately running thread.
    
    Specified by:
    
    doPrefetch in class MediaController
    
    Returns:
    true if successful.
  - abortPrefetch
```
protected final void abortPrefetch()
```
    Called when the prefetch() is aborted, i.e. deallocate() was called while prefetching. Release all resources claimed previously by the prefetch call.
    
    Specified by:
    
    abortPrefetch in class MediaController
  - flush
```
protected void flush()
```
    This should trigger a flush to the data path.
  - deviceBusy
```
protected boolean deviceBusy(MediaController mc)
```
    Check the given controller to see if it's busy or not. Needs to be overridden by subclass. The subclass method should change the master timebase if necessary. It should handle audio only or video only tracks properly when the device is busy.
    
    Returns:
    true if the given controller is usable; false if the controller cannot be used.
  - slaveToMasterTimeBase
```
protected void slaveToMasterTimeBase(TimeBase tb)
                              throws IncompatibleTimeBaseException
```
    Slave all the controllers to the master time base. The controllers should be in realized or greater state This differs from the setTimeBase() as it loops through each controllers and call setTimeBase on each of them.
    
    Parameters:
    tb - the time base to be used by all controllers.
    
    Throws:
    
    IncompatibleTimeBaseException - thrown if any controller will not accept the player's timebase.
  - processEvent
```
protected void processEvent(ControllerEvent evt)
```
    Description copied from class: MediaController
    
    Process one event from another Controller which we are listening to. This is invoked by the recvEvtQueue when there is at least one event in the queue. If you need to extend this methods, please also invoke this such that the events can be catched by the work threads.
    
    Overrides:
    
    processEvent in class MediaController
    
    Parameters:
    evt - controller event to be processed
  - doSetRate
```
protected float doSetRate(float factor)
```
    Called from setRate. This is used for subclasses to add in their own behavior.
    
    Overrides:
    
    doSetRate in class MediaController
    
    Parameters:
    factor - the rate to set to. return the actual rate should be returned
  - setRate
```
public float setRate(float rate)
```
    Set the playback rate on the player. It loops through its list of controllers and invoke setRate on each of them.
    
    Specified by:
    
    setRate in interface Clock
    
    Overrides:
    
    setRate in class MediaController
    
    Parameters:
    rate - the rate to be set
    
    Returns:
    the actual rate used.

Class MediaPlayer

Field Summary

Fields inherited from class com.sun.tv.media.MediaController

Fields inherited from interface javax.media.Controller

Fields inherited from interface javax.media.Clock

Fields inherited from interface javax.media.Duration

Constructor Summary

Method Summary

Methods inherited from class com.sun.tv.media.MediaController

Methods inherited from class java.lang.Object

Methods inherited from interface javax.media.Controller

Methods inherited from interface javax.media.Clock

Field Detail

VERSION

source

systemTimeBase

controls

gainControl

defaultColorModel

Constructor Detail

MediaPlayer

Method Detail

setSource

getSource

close

doClose

setTimeBase

setMediaLength

getDuration

updateDuration

setStopTime

setMediaTime

doSetMediaTime

setVisualComponent

getVisualComponent

getControlPanelComponent

getGainControl

gainChange

muteChange

addControls

getControls

getNodeList

start

syncStart

doStart

synchronousRealize

synchronousPrefetch

doStop

stop

stopAtTime

stop

addNode

addNode

removeNode

addController

removeController

createNodes

connectNodes

audioEnabled

videoEnabled

getMasterTimeBase

doRealize

createGainControl

completeRealize

doFailedRealize

completePrefetch

doFailedPrefetch

abortRealize

allocBuffers

doPrefetch

abortPrefetch

flush

deviceBusy

slaveToMasterTimeBase

processEvent

doSetRate

setRate