import javax.microedition.media.PlayerListener; //导入依赖的package包/类
public void playerUpdate(Player player, String event, Object eventData) {
    if (deleted) {
        return;
    }
    if (PlayerListener.ERROR.equals(event)) {
        lastTime = (int) (nativePlayer.getMediaTime() / 1000);
        cleanup();
    }
    if (PlayerListener.END_OF_MEDIA.equals(event)) {
        lastTime = (int) (nativePlayer.getMediaTime() / 1000);
        if (disposeOnComplete) {
            cleanup();
            if (sourceStream != null) {
                try {
                    sourceStream.close();
                } catch (Throwable t) {
                }
            }
        }
        if (onComplete != null) {
            onComplete.run();
        }
    }
}
 

import javax.microedition.media.PlayerListener; //导入依赖的package包/类
public void playerUpdate(Player player, String event, Object eventData) {
    if(deleted) {
        return;
    }
    if(PlayerListener.ERROR.equals(event)) {
        lastTime = (int)(nativePlayer.getMediaTime() / 1000);
        cleanup();
    }
    if(PlayerListener.END_OF_MEDIA.equals(event)) {            
        lastTime = (int)(nativePlayer.getMediaTime() / 1000);
        if(disposeOnComplete){
            cleanup();
            if(sourceStream != null) {
                try {
                    sourceStream.close();
                } catch(Throwable t) {}
            }
        }
        if(onComplete != null) {
            onComplete.run();
        }
    }
}
 

import javax.microedition.media.PlayerListener; //导入依赖的package包/类
public JrFormEntryController(JrFormEntryModel model, String extraKeyMode, boolean audioFailFast, boolean quickEntry, boolean isMinimal) {
    super(model);
    tryToInitDefaultLanguage(model);
    this.extraKeyMode = extraKeyMode;
    this.audioFailFast = audioFailFast;
    this.quickEntry = quickEntry;
    this.isMinimal = isMinimal;

    this.mMediaLogger = new PlayerListener() {
        public void playerUpdate(Player player, String event, Object eventData) {
            FormEntryPrompt fep = JrFormEntryController.this.getModel().getQuestionPrompt();
            try {
                if (fep != null && fep.getAudioText() != null) {
                    MediaUtils.logEvent(event, fep.getAudioText());
                }
            } catch(Exception e) {
                //Nothing
            }
        }
    };

    //#if device.identifier == Sony-Ericsson/K610i
    POUND_KEYCODE = Canvas.KEY_STAR;
    //#endif
}
 

import javax.microedition.media.PlayerListener; //导入依赖的package包/类
/**
 * Log that a media file was started, paused, or stopped (i.e., finished playing).
 *
 * TODO: move this to some sort of 'form entry diagnostics' framework instead of bloating the logs.
 * @param event From PlayerListener
 * @param uri Media file location
 */
public static void logEvent(String event, String uri) {
    String action = "";
    if (event == PlayerListener.STARTED) {
        action = "start";
    }
    if (event == PlayerListener.STOPPED) {
        action = "pause";
    }
    else if (event == PlayerListener.END_OF_MEDIA) {
        action = "stop";
    }
    if (!"".equals(action)) {
        try {
            Vector<String> pieces = DataUtil.split(uri, "/", false);
            uri = pieces.lastElement();
        } catch (Exception e) {
            // just use the full URI
        }
        Logger.log("media", action + ": " + uri);
    }
}
 

import javax.microedition.media.PlayerListener; //导入依赖的package包/类
public void playerUpdate(Player player, String event, Object eventData) {
  if (event == (PlayerListener.VOLUME_CHANGED)) {
    VolumeControl vc = (VolumeControl) eventData;
  //  updateDisplay("Volume Changed to: " + vc.getLevel());
    if (vc.getLevel() > 60) {
  //    updateDisplay("Volume higher than 60 is too loud");
      vc.setLevel(60);
    }
  } else if (event == (PlayerListener.STOPPED)) {
  //  updateDisplay("Player paused at: " + (Long) eventData);
  } else if (event == (PlayerListener.STARTED)) {
  // updateDisplay("Player started at: " + (Long) eventData);
  } else if (event == (PlayerListener.END_OF_MEDIA)) {
    updateDisplay(true);
  } else if (event == (PlayerListener.CLOSED)) {
    updateDisplay(true);
  } else if (event == (PlayerListener.ERROR)) {
    updateDisplay(true);
  }
}
 

import javax.microedition.media.PlayerListener; //导入依赖的package包/类
public static Player getPlayerLoose(Reference reference) throws MediaException, IOException {
    Player thePlayer;

    try{
        thePlayer = Manager.createPlayer(reference.getLocalURI());
        final String uri = reference.getLocalURI();
        thePlayer.addPlayerListener(new PlayerListener() {
            public void playerUpdate(Player player, String event, Object eventData) {
                logEvent(event, uri);
            }
        });
        return thePlayer;
    } catch(MediaException e) {
        if(!FormManagerProperties.LOOSE_MEDIA_YES.equals(PropertyManager._().getSingularProperty(FormManagerProperties.LOOSE_MEDIA))) {
            throw e;
        }
        Reference[] refs = reference.probeAlternativeReferences();
        for(Reference ref : refs) {
            if(ref.doesBinaryExist()) {
                try{
                    //TODO: Make sure you create a player of the right type somehow (video/audio), don't want
                    //to accidentally send back an audio player of a video file
                    thePlayer = Manager.createPlayer(ref.getLocalURI());
                    return thePlayer;
                }catch(MediaException oe) {
                    //also bad file, keep trying
                }
            }
        }
        throw e;
    }
}
 

import javax.microedition.media.PlayerListener; //导入依赖的package包/类
public void setDisplaySize(int width, int height)
    throws javax.microedition.media.MediaException {
    checkState();
    if (width < 1 || height < 1)
        throw new IllegalArgumentException("Invalid size");
    
    boolean sizeChanged = (dw != width || dh != height);
    
    if (fsmode) { // Just store sizes in fullscreen mode
        synchronized (dispBoundsLock) {
            tmpdw = width;
            tmpdh = height;
        }
    } else {
        synchronized (dispBoundsLock) {
            dw = width;
            dh = height;
        }
        scaleToDest();
        if (pvis)
            if (mmItem != null)
                mmItem.refresh(true);
            else if (cvis)                   
                canvas.repaint();
    }
    // Makes sense only if NOT in Full Screen mode
    if (sizeChanged && !fsmode)
        player.sendEvent(PlayerListener.SIZE_CHANGED, this);
}
 

import javax.microedition.media.PlayerListener; //导入依赖的package包/类
/**
 * PlayerListener interface's method.
 */
public void playerUpdate(Player player, String event, Object eventData) {
    if (event.equals(PlayerListener.VOLUME_CHANGED)) { // Gauge is adjusted
        actualVolume = (int) (((float) globalVolume / 100) * (float) midletVolume);
    } else if (event.equals("com.nokia.external.volume.event")) {
        // External volumes keys are pressed                
        globalVolume = Integer.parseInt(eventData.toString());
        actualVolume = (int) (((float) globalVolume / 100) * (float) midletVolume);
    }
    midlet.actualVolume = actualVolume;
    midlet.globalVolume = globalVolume;
    midlet.midletVolume = midletVolume;
    midlet.eventString = event;
    midlet.updateVolume();
}
 

import javax.microedition.media.PlayerListener; //导入依赖的package包/类
public void playerUpdate(Player player, String event, Object eventData) {
    try {
        if (event.equals(PlayerListener.STARTED)) {
            setStatusText("Started.");
        } else if (event.equals(PlayerListener.END_OF_MEDIA)) {
            this.player.restartPlayer();
        } else if (event.equals(PlayerListener.VOLUME_CHANGED)) {
            // Volume has been changed
        }
    } catch (Exception ex) {
        exceptionOccurred(ex);
    }
}
 

import javax.microedition.media.PlayerListener; //导入依赖的package包/类
public void statusEvent(String msg) {
    if (msg.equals(PlayerListener.END_OF_MEDIA)) {
        setStatusText("Connection to slow!");
    } else if (msg.equals(PlayerListener.VOLUME_CHANGED)) {
        setStatusText("Volume was changed");
    } else {
        setStatusText(msg);
    }
}
 

import javax.microedition.media.PlayerListener; //导入依赖的package包/类
public synchronized void restartPlayer() {
    try {
        fireStatusEvent("Wait...");
        IN.nextChunk();

        // Free old player
        if (player != null) {
            for (int n = 0; n < listeners.size(); n++) {
                this.player.removePlayerListener((PlayerListener) listeners.elementAt(n));
            }
            this.player.close();
            this.player = null;
        }

        fireStatusEvent("Create Player...");
        this.player = Manager.createPlayer(IN, IN.getContentType());
        this.player.realize();

        // Make sure radio is audible; this causes an VOLUME_CHANGED event
        VolumeControl vcon = (VolumeControl) this.player.getControl("VolumeControl");
        vcon.setMute(false);
        vcon.setLevel(50);

        for (int n = 0; n < listeners.size(); n++) {
            this.player.addPlayerListener((PlayerListener) listeners.elementAt(n));
        }

        fireStatusEvent("Starting...");
        this.player.start();
    } catch (Exception ex) {
        fireExecptionOccurredEvent(ex);
    }
}
 

import javax.microedition.media.PlayerListener; //导入依赖的package包/类
public void setDisplayFullScreen(boolean fullScreenMode)
    throws javax.microedition.media.MediaException {
    checkState();
    if (fsmode != fullScreenMode) {
        fsmode = fullScreenMode;
        if (fsmode) { //switching from Normal to Full Screen
            synchronized (dispBoundsLock) {
                tmpdx = dx;
                tmpdy = dy;
                tmpdw = dw;
                tmpdh = dh;
            }
            if (mode == USE_DIRECT_VIDEO) {
                canvas.setFullScreenMode(true);
            } else {
                canvas = mmItem.toFullScreen(this, this);
                if (canvas == null) {
                    // No owner or no display - thus invisible
                    // Do nothing, but simulate fullscreen (lock sizes - for compliance)
                    return;
                }                        
            }
            synchronized (dispBoundsLock) {
                dx = 0;
                dy = 0;
                                    
                // Keep aspect ratio
                int scrw = canvas.getWidth();
                int scrh = canvas.getHeight();
                dw = scrh * videoWidth / videoHeight;
                if (dw > scrw) {
                    dw = scrw;
                    dh = scrw * videoHeight / videoWidth;
                    dy = (scrh - dh) / 2;
                } else {
                    dh = scrh;
                    dx = (scrw - dw) / 2;
                }
            }
            scaleToDest();
            if (cvis)
                canvas.repaint();

        } else { //switching from Full to Normal Screen
            synchronized (dispBoundsLock) {
                dx = tmpdx;
                dy = tmpdy;
                dw = tmpdw;
                dh = tmpdh;
            }
            scaleToDest();
            if (mode == USE_DIRECT_VIDEO) {
                canvas.setFullScreenMode(false);
                if (pvis && cvis)
                    canvas.repaint();
            } else {
                mmItem.toNormal();
                canvas = null;
                if (pvis)
                    mmItem.refresh(false);
            }
        }
        player.sendEvent(PlayerListener.SIZE_CHANGED, this);
    }
}
 

import javax.microedition.media.PlayerListener; //导入依赖的package包/类
public void playerUpdate(Player player, String string, Object object) {
if (string.equals(PlayerListener.END_OF_MEDIA)) {    release(); }
   }