.#settings.java.1.5.6.1

国外的j2me播放器软件

								currentMediaRenderer < mrList.length) 
							{
								MediaRenderer mr = mrList[currentMediaRenderer];
								saveUPnPDevice(RECORDID_SETTING_MEDIARENDERER,mr);
							}
							break;
						}
						case RECORDID_SETTING_REPEAT: {
							saveBooleanValue(RECORDID_SETTING_REPEAT, repeat);
							break;
						}
						case RECORDID_SETTING_SHUFFLE: {
							saveBooleanValue(RECORDID_SETTING_SHUFFLE, shuffle);
							break;
						}
						case RECORDID_SETTING_HOSTINGPORT: {
							saveIntValue(RECORDID_SETTING_HOSTINGPORT, hostingPort);
							break;
						}
					}
				}
		    // XXX save to RMS
		    settingsStore.closeRecordStore();
		    }
			catch (RecordStoreException rse) {
				LOG.debug("RS Exception...");
		        rse.printStackTrace();
			}
		}
	}

	/**
     * Sets the current MediaRenderer to be used, based on the {@linkplain no.auc.one.portableplayer.librarymanager.LibraryMgr#renderers available renderers}.
     * 
	 * @param index The index to the AVRenderer element in the renderers Vector 
     *              in the LibraryMgr which should be set as current renderer, SET TO -1 TO USE INTERNAL RENDERER.
	 */
	public void setCurrentMediaRendererIndex(int index) {
        currentMediaRenderer = index;
	    settingsChanged = true;

        for(Enumeration e = mediaRendererChangedListeners.elements(); 
            e.hasMoreElements();) 
        {
            MediaRendererChanged mrc = (MediaRendererChanged)e.nextElement();
            mrc.mediaRendererChanged(currentMediaRenderer);
        }
	}
    
	/**
     * Get the index of the current {@link no.auc.one.portableplayer.communication.mediarenderer.MediaRenderer MediaRenderer} in use.
     * 
	 * @return The index to the AVRenderer element in the renderers Vector in the 
     *         LibraryMgr which is set as current renderer, IF -1, USE INTERNAL RENDERER
	 */
	public int getCurrentMediaRendererIndx() {
		return currentMediaRenderer;
	}
	
	// XXX Add update and get mr list and whatnot methods...
	
	public void updateMediaServerList() {
		LOG.debug("updateMediaServerList start");
//		synchronized(msList) {
			LOG.debug("sync with msList");
			try {
				LOG.debug("starting to find ms");
				isUpdatingMediaServerList = true;
				LOG.debug("msList = " + msList + "\tmsf = " + msf);
				LOG.debug("do find ms");
				msList = msf.findMediaServers();
			} catch (Exception e) {
				System.out.println("Exception while updating MS list");
				e.printStackTrace();
				msList = null;
			} finally {
				isUpdatingMediaServerList = false;
			}
//		}
	}
	
	public void addMediaServerByLocationUrl(String locationUrl) {
		
		try {
			LOG.debug("Starting to find ms device description");
			isUpdatingMediaServerList = true;
			LOG.debug("msList = " + msList + "\tmsf = " + msf);
			
			msList = new MediaServer[1];
			msList[0] = msf.getMediaServer(locationUrl);
		} catch (Exception e) {
			System.out.println("Exception while updating MS list");
			e.printStackTrace();
			msList = null;
		} finally {
			isUpdatingMediaServerList = false;
		}
	}
	
	public void addMediaServerByUDN(String UDN) {
		
		try {
			LOG.debug("Starting to find ms based on UDN");
			isUpdatingMediaServerList = true;
			LOG.debug("msList = " + msList + "\tmsf = " + msf);
			msList = msf.findMediaServers(UDN);
		} catch (Exception e) {
			System.out.println("Exception while updating MS list");
			e.printStackTrace();
			msList = null;
		} finally {
			isUpdatingMediaServerList = false;
		}
	}
	
	
	public void updateMediaRendererList() {
		LOG.debug("updateMediaRendererList start");
//		synchronized(mrList) {
			try {
				LOG.debug("starting to find mr");
				isUpdatingMediaRendererList = true;
				LOG.debug("mrList = " + mrList + "\tmsf = " + mrf);
				LOG.debug("do find mr");
				mrList = mrf.findMediaRenderers();
			} catch (Exception e) {
				System.out.println("Exception while updating MR list");
				e.printStackTrace();
				mrList = null;
			} finally {
				isUpdatingMediaRendererList = false;
			}
//		}
	}
	
	
	public void addMediaRendererByLocationUrl(String locationUrl) {
		
		try {
			LOG.debug("Starting to find mr device description");
			isUpdatingMediaRendererList = true;
			LOG.debug("mrList = " + mrList + "\tmsf = " + mrf);
			mrList = new MediaRenderer[1];
			mrList[0] = mrf.getMediaRenderer(locationUrl);
		} catch (Exception e) {
			System.out.println("Exception while updating MR list");
			e.printStackTrace();
			mrList = null;
		} finally {
			isUpdatingMediaRendererList = false;
		}
	}
	
	public void addMediaRendererByUDN(String UDN) {
		
		try {
			LOG.debug("Starting to find mr based on UDN");
			isUpdatingMediaRendererList = true;
			LOG.debug("mrList = " + mrList + "\tmsf = " + mrf);
			mrList = mrf.findMediaRenderers(UDN);
		} catch (Exception e) {
			System.out.println("Exception while updating MR list");
			e.printStackTrace();
			mrList = null;
		} finally {
			isUpdatingMediaRendererList = false;
		}
	}
	
	
	public void cancelUpdateMediaServerList() throws java.io.IOException {
		try {
			msf.cancel();
		} finally {
			isUpdatingMediaServerList = false;
		}
	}
	
	public void cancelUpdateMediaRendererList() throws java.io.IOException {
		try {
			mrf.cancel();
		} finally {
			isUpdatingMediaRendererList = false;
		}
	}
	
	public void setUpdatingMediaServerList(boolean isUpdatingMediaServerList) {
		this.isUpdatingMediaServerList = isUpdatingMediaServerList;
	}
	
	public boolean isUpdatingMediaServerList() {
		return isUpdatingMediaServerList;
	}
	
	public void setUpdatingMediaRendererList(boolean isUpdatingMediaRendererList) {
		this.isUpdatingMediaRendererList = isUpdatingMediaRendererList;
	}
	
	public boolean isUpdatingMediaRendererList() {
		return isUpdatingMediaRendererList;
	}

    public void setCurrentMediaServerIndex(int index) {
        currentMediaServer = index;
		settingsChanged = true;
        
        for(Enumeration e = mediaServerChangedListeners.elements(); 
            e.hasMoreElements();) 
        {
            MediaServerChanged msc = (MediaServerChanged)e.nextElement();
            msc.mediaServerChanged(currentMediaServer);
        }
    }

    public int getCurrentMediaServerIndex() {
        return currentMediaServer;
    }
	
	public MediaServer[] getMediaServerList() {
		return msList;
	}
	
	public MediaRenderer[] getMediaRendererList() {
		return mrList;
	}
	
	public MediaServer getCurrentMediaServer() {
		return getMediaServer(currentMediaServer);
	}
	
	public MediaRenderer getCurrentMediaRenderer() {
		return getMediaRenderer(currentMediaRenderer);
	}
	
	public MediaServer getMediaServer(int index) {
		if (index < 0 || index > msList.length) {
			throw new IllegalArgumentException();
		}
		
		return msList[index];
	}
	
	public MediaRenderer getMediaRenderer(int index) {
		if (index < 0 || index > mrList.length) {
			throw new IllegalArgumentException();
		}
		
		return mrList[index];
	}
    
	/**
     * Set repeat mode.
     * 
	 * @param repeat Set repeat on = true or off = false
	 */
	public void setRepeatSetting(boolean repeat) {
		this.repeat = repeat;
		settingsChanged = true;
        
        for(Enumeration e = playModeRepeatChangedListeners.elements(); 
            e.hasMoreElements();) 
        {
            PlayModeRepeatChanged pmrc = (PlayModeRepeatChanged)e.nextElement();
            pmrc.playModeRepeatChanged(this.repeat);
        }
	}
	/**
     * Get repeat mode.
     * 
	 * @return Return the setting of repeat, true = on or false = off
	 */
	public boolean getRepeatSetting() {
		return repeat;
	}
	
	/**
     * Set shuffle mode.
     * 
	 * @param shuffle Set shuffle on = true or off = false
	 */
	public void setShuffleSetting(boolean shuffle) {
		this.shuffle = shuffle;
		settingsChanged = true;
        
        for(Enumeration e = playModeRepeatChangedListeners.elements(); 
            e.hasMoreElements();) 
        {
            PlayModeShuffleChanged pmsc = (PlayModeShuffleChanged)e.nextElement();
            pmsc.playModeShuffleChanged(this.shuffle);
        }
	}
	/**
     * Get shuffle mode.
     * 
	 * @return Return the setting of shuffle, true = on or false = off
	 */
	public boolean getShuffleSetting() {
		return shuffle;
	}
	
	/**
     * Toggle Hosting port setting between auto and manual
	 */
	public void toggleHostingPortSetting() {
	    if (hostingPort == -1) {
	        hostingPort = manuallySelectedHostingPort;
	    }
	    else {
	        hostingPort = -1;
	    }
	    settingsChanged = true;
	}
	
	/**
     * Set Hosting port number.
     * 
	 * @param hostingPort Set hosting port user-defined or auto = -1
	 */
	public void setManuallySelectedHostingPort(int hostingPort) {
		manuallySelectedHostingPort = hostingPort;
		settingsChanged = true;
	}
	/**
     * Get Hosting port number.
     * 
	 * @return Return the setting of hostingPort, user-defined or auto = -1
	 */
	public int getHostingPortSetting() {
		return hostingPort;
	}

    public void addMediaRendererChangedListener(MediaRendererChanged mrc) {
        mediaRendererChangedListeners.addElement(mrc);
    }

    public void addMediaServerChangedListener(MediaServerChanged msc) {
        mediaServerChangedListeners.addElement(msc);
    }

    public void addPlayModeShuffleChangedListener(PlayModeShuffleChanged pmsc) {
        playModeShuffleChangedListeners.addElement(pmsc);
    }

    public void addPlayModeRepeatChangedListener(PlayModeRepeatChanged prmsc) {
        playModeRepeatChangedListeners.addElement(prmsc);
    }
}