////////////////////////////////////////////////////////////////////////
/// Tuning
//
// returns the number of available tuners or -1 on ERROR
public int GetNumTuners();
// returns the index of the service currently tuned on tuner or -1 on ERROR
public int GetTunerServiceIndex(int tunerIndex);
// returns the number of available services or -1 on ERROR
public int GetNumServices();
// returns the string representation of the service at the given index
public String GetServiceInfo(int serviceIndex);
// returns the service name for the service at the given index
public String GetServiceName(int serviceIndex);
// select the service (by the given name) for the given tuner index
public boolean ServiceSelectByName(int tunerIndex, String serviceName);
// select the service (by the given index) for the given tuner index
public boolean ServiceSelectByIndex(int tunerIndex, int serviceIndex);
////////////////////////////////////////////////////////////////////////
/// TSB
//
// enable or disable the TSB for the given tuner (by index)
public boolean TsbControl(int tunerIndex, boolean enable);
// return the enabled state of the TSB for the given tuner (by index)
public boolean IsTsbEnabled(int tunerIndex);
// return the boolean ability to create a file of the given size
public boolean CheckDiskSpace(long fileSize);
////////////////////////////////////////////////////////////////////////
/// Recording
//
// record the service on the given tuner for the given duration starting
// after the given delay in the background if set.
// returns the recording index to be used in subsequent calls or -1 on ERROR
public int RecordTuner(int tunerIndex, long duration, long delay,
boolean background);
// record the given service for the given duration starting after the
// given delay in the background if set.
// returns the recording index to be used in subsequent calls or -1 on ERROR
public int RecordService(int serviceIndex, long duration, long delay,
boolean background);
// wait for the recording (provided index) to reach the given state or
// the given timeout occurs.
// return TRUE if the state was attained, else FALSE
public boolean WaitForRecordingState(int recordingIndex, long timeout,
String recordingState);
// stop the given recording
// return TRUE if successful, else FALSE
public boolean RecordingStop(int recordingIndex);
// return the number of available recordings or -1 on ERROR
public int GetNumRecordings();
// return the recording's (provided index) current state
public String GetRecordingState(int recordingIndex);
// return the recording's (provided index) duration
long GetRecordingDuration(int recordingIndex);
// delete all recordings
// return TRUE if successful, else FALSE
public boolean DeleteAllRecordings();
////////////////////////////////////////////////////////////////////////
/// Generic Playback
//
// start the given playback
// return TRUE if successful, else FALSE
public boolean PlaybackStart(int playbackIndex);
// stop the given playback
// return TRUE if successful, else FALSE
public boolean PlaybackStop(int playbackIndex);
// return the given playback's current rate
public float GetPlaybackRate(int playbackIndex);
// set the given playback's rate
// return TRUE if successful, else FALSE
public boolean SetPlaybackRate(int playbackIndex, int rateIndex);
// return the given playback's current position
public long GetPlaybackPosition(int playbackIndex);
// set the given playback's position
// return TRUE if successful, else FALSE
public boolean SetPlaybackPosition(int playbackIndex, long time);
// return the value in the table of possible rates at the given index
// or 0.0 on error
public float GetPlayRate(int rateIndex);
// return the index of the given rate in the table of possible rates
// or -1 on error
public int GetPlayRateIndex(float rate);
////////////////////////////////////////////////////////////////////////
/// DVR Local Playback
//
// create a DVR player for the given recording and play for the given
// duration starting in the given delay.
// returns the playback index to be used in subsequent calls or -1 on ERROR
public int CreateDvrPlayback(int recordingIndex, long duration, long delay);
// delete a DVR player based on the given index
// return TRUE if successful, else FALSE
public boolean DeleteDvrPlayback(int playbackIndex);
////////////////////////////////////////////////////////////////////////
/// HN Playback
//
// create a HN player for the given content item (by index) of a given
// type and play for the given duration starting in the given delay.
// returns the playback index to be used in subsequent calls or -1 on ERROR
public int CreateHnPlayback(String playerType, int contentItemIndex,
long duration, long delay);
// delete a HN player based on the given index
// return TRUE if successful, else FALSE
public boolean DeleteHnPlayback(int playbackIndex);
// select the given HN server for the given HN player
// return TRUE if successful, else FALSE
public boolean HNPlaybackSelectServer(int playbackIndex, int serverIndex);
////////////////////////////////////////////////////////////////////////
/// HN General Functions
//
// returns the number of ContentServers on the network or -1 on ERROR
public int GetNumHnMediaServersOnNetwork();
// return a string representation of the given server
public String GetHnMediaServerInfo(int serverIndex);
// return the number of content items on the given server or -1 on ERROR
public int GetNumHnServerContentItems(int serverIndex);
// return a string representation of the given content on the given server
public String GetHnServerContentItemInfo(int serverIndex,
int contentItemIndex);
// returns the number of non-local devices on the network or -1 on ERROR
public int GetNumHnDevicesOnNetwork();
// return a string representation of the given device
public String GetHnDeviceInfo(int deviceIndex);
// update the "Friendly Name" of the root device to the given name
// return TRUE if successful, else FALSE
public boolean HNChangeRootDeviceFriendlyName(String newName);
// update the UDN of the local media server to the given UDN
// return TRUE if successful, else FALSE
public boolean HNChangeLocalMediaServerUDN(String newUDN);
// force the root device to send a UPnP bye-bye
// return TRUE if successful, else FALSE
public boolean HNSendRootDeviceByeBye();
// force the root device to send a UPnP alive
// return TRUE if successful, else FALSE
public boolean HNSendRootDeviceAlive();
// return the index of the local media server or -1 on ERROR
public int HNFindLocalMediaServer();
// returns the number of network interfaces or -1 on ERROR
public int HNGetNumNetworkInterfaces();
// return a string representation of the given network interface
public String HNGetNetworkInterfaceInfo(int interfaceIndex);
////////////////////////////////////////////////////////////////////////
/// HN Media Server
//
// publish the given recording (by index) to the CDS
// return TRUE if successful, else FALSE
public boolean PublishRecording(int recordingIndex);
// publish all recordings found to the CDS
// return TRUE if successful, else FALSE
public boolean PublishAllRecordings();
// publish the given service (by index) to the CDS
// return TRUE if successful, else FALSE
public boolean PublishService(int serviceIndex);
// publish all services found to the CDS
// return TRUE if successful, else FALSE
public boolean PublishAllServices();
// publish the given service (by index) to the CDS
// return TRUE if successful, else FALSE
public boolean PublishServiceUsingAltRes(int serviceIndex);
// publish all services found to the CDS
// return TRUE if successful, else FALSE
public boolean PublishAllServicesUsingAltRes();
// publish the given personal content file (by URL) to the CDS
// return TRUE if successful, else FALSE
public boolean PublishPersonalContentFileToCDS(String url);
////////////////////////////////////////////////////////////////////////
/// Resource Contention Handling
//
// returns the number of pre-defined Resource Contention Handlers
// or -1 on ERROR
public int GetNumResourceContentionHandlers();
// return a string representation of the given RCH
public String GetResourceContentionHandlerInfo(int rchIndex);
// pre-select a pre-defined Resource Contention Handler to use on
// the next contention.
// return TRUE if successful, else FALSE
public boolean PreselectResourceContentionHandler(int rchIndex);
// select a pre-defined Resource Contention Handler to use for
// the current contention.
// return TRUE if successful, else FALSE
public boolean SelectResourceContentionHandler(int rchIndex);