Playing songs in a sequencer one after another

[Kyle Kerlew]

Say I have an entire directory full of midi songs, and I want to add them to a sequencer and play them one after another in order, how would I go about doing that?

Here is the class if you need it to help me,
I'm new here and I don't know if there are code tags or not (I'm mobile if it makes a difference)

package sign;

import java.io.File;
import java.io.IOException;
import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MetaEventListener;
import javax.sound.midi.MetaMessage;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.MidiUnavailableException;
import javax.sound.midi.Sequence;
import javax.sound.midi.Sequencer;
import javax.sound.midi.Synthesizer;
/**
 * Midi file playing.
 * @author Tony.
 * @edit 
Kyle Kerlew
 * Actions for the end of a MIDI added
 */public class Midi {         
     /**        
      * File directory.        
      */        private static final String 
      defaultFileDirectory = signlink.findcachedir() + "/Music/";
      private File 
      fileDirectory;
      private String archiveDirectory;
      /**        
       * The name of the midi file.        
       */        private String fileName;

       /**        
        * The Sequence object.        
        */        private Sequence sequence;

        /**        
         * The Sequencer object.        
         */        private static 
         Sequencer sequencer;
         /**        
          * The Synthesizer object.        
          */    
         @SuppressWarnings("unused")        private Synthesizer synthesizer;

         /**        
          * Constructs a Midi object using the default file directory.         
          * @param theFileName the name of the file        
          */
        public Midi(String theFileName)
        {
               archiveDirectory = defaultFileDirectory + 
                  theFileName;
               fileDirectory = new File(archiveDirectory);
          } 
          /**        
           * Constructs a midi object using the specified filedirectory        
           * @param theFileDirectory specified file directory to the file archive.  
           * @param theFileName name of the midi file.        
           */   
          public Midi(String theFileDirectory, String theFileName)
        {           
              archiveDirectory = defaultFileDirectory + theFileDirectory + theFileName;

              fileDirectory = new File(archiveDirectory);
          }   
          /**         
           * Sets the name of the midi file         
           * @param theFileName the name of the file        
           * @return fileName        
           */        
          public String 
          setFileName(String theFileName)
        {
              return fileName = 
                      theFileName;
          }
          /**         
           * Starts the midi file to play.        
           */
          public void play()
        {        
              try
              {       
                  sequence = MidiSystem.getSequence(fileDirectory);
                  sequencer =  MidiSystem.getSequencer();
                  sequencer.setSequence(sequence);
                  sequencer.open();
                  sequencer.start();

                  switch (Music.PLAYLIST_MODE)
                  {
                      case 1:                  
                          sequencer.addMetaEventListener(new MetaEventListener() {           
                              public void meta(MetaMessage msg) {                 
                                  if (msg.getType() == 0x2F) { // End of track      
                                      Music.playRandom();
                                  }
                              }   
                          });
                          break;

                      case 2: //plays the songs in order from the directory               
                          sequencer.setSequence(/* ????? */);
                          break;

                      case 3://                                break;

                      default:                                
                          System.out.println("Not specified");
                          break;

                  }
              }
              catch (InvalidMidiDataException | IOException | MidiUnavailableException e)     
              {     
                  e.printStackTrace();
              }
          }         
          /**        
           * Stops the midi file from playing.        
           */
          public static void stop()
        {     
              if (!sequencer.isOpen())                        
                  System.out.println("Nothing is playing");
              else                    
                  sequencer.stop();
              sequencer.close();

              Music.playingR = false;
          }

          public String getFileName()
          { 
              return fileName;
          }
 }

[Campbell Ritchie]

Welcome to the Ranch
Please post the class here; many people are reluctant to download things from unfamiliar sites.

[Kyle Kerlew]

Thank you, assuming there are code tags, how do you use them?

[Maneesh Godbole]

Here you go https://coderanch.com/how-to/java/UseCodeTags

[Campbell Ritchie]

My, didn't that website mangle your code. That is what happens when you have the wrong line end combination. I have tried to sort it out, by copying to an IDE and using find‑and‑replace and ctrl‑I to sort out the indentation. I hope I have got it right.
Why are you using a static method for stop and instance methods for everything else?

[Kyle Kerlew]

stop is acessed statically outside the class

[Mark Koontz]

Just thinking out loud. I've never done this before, which is probably why the question made me curious enough to take a look.

Playing a list of files requires implementing the MetaEventListener interface so that you are notified of the end-of-track meta event (event.getType() == 47). This is probably the main question you have.

Rather than using a switch structure, you might consider employing a factory pattern, with a static method like public static MidiPlayer getMidiPlayer(File midi). If "midi" is a file, the factory returns an instance of a MidiFilePlayer. If "midi" is a directory, the factory returns an instance of a MidiDirectoryPlayer class that knows how to cycle through a list of files, randomly or in some order, using MidiFilePlayer. Otherwise, your play() method might smell.

Since the Sequencer start() method is asynchronous, you'd want to think about how to handle the end of file event. For example, you might implement or extend MidiFilePlayer to allow for a synchronous play() method, where the play() method itself waits for the end-of-file event before returning. Or you could provide a playAndWait() method. Otherwise, the caller will need to be able to add itself to the sequencer's MetaEventListener list. Or MidiFilePlayer could emit an end-of-file event. Options options options.

[Campbell Ritchie]

Welcome to the Ranch Mark Koontz