Page History

/// 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);