Coding World

android media player connecting status with audio streaming link(ie 2%,4%…100% then online radio start to play) in android

2013-11-29T21:33:00.001-08:00

when user click play button to play radio then i want to show connecting status(buffering 1%,2%.. 99%). when status will be 100% radio start to play. i was face problem to solve this. so here i share this code for all.

at first create this class ______________________
public class StreamingMediaPlayer {

    private static final int INTIAL_KB_BUFFER = 96*10/8;//assume 96kbps*10secs/8bits per byte

    private TextView textStreamed;

    private ImageButton playButton;

    private ProgressBar    progressBar;

    // Track for display by progressBar
    private long mediaLengthInKb, mediaLengthInSeconds;
    private int totalKbRead = 0;

    // Create Handler to call View updates on the main UI thread.
    private final Handler handler = new Handler();

    private MediaPlayer     mediaPlayer;

    private File downloadingMediaFile;

    private boolean isInterrupted;

    private Context context;

    private int counter = 0;

     public StreamingMediaPlayer(Context context,TextView textStreamed, ImageButton    playButton, Button    streamButton,ProgressBar    progressBar)
     {
         this.context = context;
        this.textStreamed = textStreamed;
        this.playButton = playButton;
        this.progressBar = progressBar;
    }

    /**
     * Progressivly download the media to a temporary location and update the MediaPlayer as new content becomes available.
     */
    public void startStreaming(final String mediaUrl, long    mediaLengthInKb, long    mediaLengthInSeconds) throws IOException {

        this.mediaLengthInKb = mediaLengthInKb;
        this.mediaLengthInSeconds = mediaLengthInSeconds;

        Runnable r = new Runnable() {
            public void run() {
                try {
                    downloadAudioIncrement(mediaUrl);
                } catch (IOException e) {
                    Log.e(getClass().getName(), "Unable to initialize the MediaPlayer for fileUrl=" + mediaUrl, e);
                    return;
                }
            }
        };
        new Thread(r).start();
    }

    /**
     * Download the url stream to a temporary location and then call the setDataSource
     * for that local file
     */
    public void downloadAudioIncrement(String mediaUrl) throws IOException {

        URLConnection cn = new URL(mediaUrl).openConnection();
        cn.connect();
        InputStream stream = cn.getInputStream();
        if (stream == null) {
            Log.e(getClass().getName(), "Unable to create InputStream for mediaUrl:" + mediaUrl);
        }

        downloadingMediaFile = new File(context.getCacheDir(),"downloadingMedia.dat");
        if (downloadingMediaFile.exists()) {
            downloadingMediaFile.delete();
        }

        FileOutputStream out = new FileOutputStream(downloadingMediaFile);
        byte buf[] = new byte[16384];
        int totalBytesRead = 0, incrementalBytesRead = 0;
        do {
            int numread = stream.read(buf);
            if (numread <= 0)
                break;
            out.write(buf, 0, numread);
            totalBytesRead += numread;
            incrementalBytesRead += numread;
            totalKbRead = totalBytesRead/1000;

            testMediaBuffer();
               fireDataLoadUpdate();
        } while (validateNotInterrupted());
               stream.close();
        if (validateNotInterrupted()) {
               fireDataFullyLoaded();
        }
    }

    private boolean validateNotInterrupted() {
        if (isInterrupted) {
            if (mediaPlayer != null) {
                mediaPlayer.pause();
                //mediaPlayer.release();
            }
            return false;
        } else {
            return true;
        }
    }


    /**
     * Test whether we need to transfer buffered data to the MediaPlayer.
     * Interacting with MediaPlayer on non-main UI thread can causes crashes to so perform this using a Handler.
     */
    private void testMediaBuffer() {
        Runnable updater = new Runnable() {
            public void run() {
                if (mediaPlayer == null) {
                    // Only create the MediaPlayer once we have the minimum buffered data
                    if ( totalKbRead >= INTIAL_KB_BUFFER) {
                        try {
                            startMediaPlayer();
                        } catch (Exception e) {
                            Log.e(getClass().getName(), "Error copying buffered conent.", e);
                        }
                    }
                } else if ( mediaPlayer.getDuration() - mediaPlayer.getCurrentPosition() <= 1000 ){
                    // NOTE: The media player has stopped at the end so transfer any existing buffered data
                    // We test for < 1second of data because the media player can stop when there is still
                    // a few milliseconds of data left to play
                    transferBufferToMediaPlayer();
                }
            }
        };
        handler.post(updater);
    }

    private void startMediaPlayer() {
        try {
            File bufferedFile = new File(context.getCacheDir(),"playingMedia" + (counter++) + ".dat");

            // We double buffer the data to avoid potential read/write errors that could happen if the
            // download thread attempted to write at the same time the MediaPlayer was trying to read.
            // For example, we can't guarantee that the MediaPlayer won't open a file for playing and leave it locked while
            // the media is playing. This would permanently deadlock the file download. To avoid such a deadloack,
            // we move the currently loaded data to a temporary buffer file that we start playing while the remaining
            // data downloads.
            moveFile(downloadingMediaFile,bufferedFile);

            Log.e(getClass().getName(),"Buffered File path: " + bufferedFile.getAbsolutePath());
            Log.e(getClass().getName(),"Buffered File length: " + bufferedFile.length()+"");

            mediaPlayer = createMediaPlayer(bufferedFile);

            // We have pre-loaded enough content and started the MediaPlayer so update the buttons & progress meters.
            mediaPlayer.start();
            startPlayProgressUpdater();
            playButton.setEnabled(true);
        } catch (IOException e) {
            Log.e(getClass().getName(), "Error initializing the MediaPlayer.", e);
            return;
        }
    }

    private MediaPlayer createMediaPlayer(File mediaFile)
    throws IOException {
        MediaPlayer mPlayer = new MediaPlayer();
        mPlayer.setOnErrorListener(
                new MediaPlayer.OnErrorListener() {
                    public boolean onError(MediaPlayer mp, int what, int extra) {
                        Log.e(getClass().getName(), "Error in MediaPlayer: (" + what +") with extra (" +extra +")" );
                        return false;
                    }
                });

        // It appears that for security/permission reasons, it is better to pass a FileDescriptor rather than a direct path to the File.
        // Also I have seen errors such as "PVMFErrNotSupported" and "Prepare failed.: status=0x1" if a file path String is passed to
        // setDataSource(). So unless otherwise noted, we use a FileDescriptor here.
        FileInputStream fis = new FileInputStream(mediaFile);
        mPlayer.setDataSource(fis.getFD());
        mPlayer.prepare();
        return mPlayer;
    }

    /**
     * Transfer buffered data to the MediaPlayer.
     * NOTE: Interacting with a MediaPlayer on a non-main UI thread can cause thread-lock and crashes so
     * this method should always be called using a Handler.
     */
    private void transferBufferToMediaPlayer() {
        try {
            // First determine if we need to restart the player after transferring data...e.g. perhaps the user pressed pause
            boolean wasPlaying = mediaPlayer.isPlaying();
            int curPosition = mediaPlayer.getCurrentPosition();

            // Copy the currently downloaded content to a new buffered File. Store the old File for deleting later.
            File oldBufferedFile = new File(context.getCacheDir(),"playingMedia" + counter + ".dat");
            File bufferedFile = new File(context.getCacheDir(),"playingMedia" + (counter++) + ".dat");

            // This may be the last buffered File so ask that it be delete on exit. If it's already deleted, then this won't mean anything. If you want to
            // keep and track fully downloaded files for later use, write caching code and please send me a copy.
            bufferedFile.delete();
            moveFile(downloadingMediaFile,bufferedFile);

            // Pause the current player now as we are about to create and start a new one. So far (Android v1.5),
            // this always happens so quickly that the user never realized we've stopped the player and started a new one
            mediaPlayer.pause();

            // Create a new MediaPlayer rather than try to re-prepare the prior one.
            mediaPlayer = createMediaPlayer(bufferedFile);
            mediaPlayer.seekTo(curPosition);

            // Restart if at end of prior buffered content or mediaPlayer was previously playing.
            //    NOTE: We test for < 1second of data because the media player can stop when there is still
            // a few milliseconds of data left to play
            boolean atEndOfFile = mediaPlayer.getDuration() - mediaPlayer.getCurrentPosition() <= 1000;
            if (wasPlaying || atEndOfFile){
                mediaPlayer.start();
            }

            // Lastly delete the previously playing buffered File as it's no longer needed.
            oldBufferedFile.delete();


        }catch (Exception e) {
            Log.e(getClass().getName(), "Error updating to newly loaded content.", e);
        }
    }

    private void fireDataLoadUpdate() {
        Runnable updater = new Runnable() {
            public void run() {
                if((totalKbRead>19)&&(totalKbRead<120))
                    textStreamed.setText((totalKbRead-19 + "% Buffering"));//show buffering status.. ie 1%,2%. in ui
                else if(totalKbRead<19)
                    textStreamed.setText(("Connecting..."));
                else
                textStreamed.setText((""));

                float loadProgress = ((float)totalKbRead/(float)mediaLengthInKb);
                progressBar.setSecondaryProgress((int)(loadProgress*100));
            }
        };
        handler.post(updater);
    }

    private void fireDataFullyLoaded() {
        Runnable updater = new Runnable() {
            public void run() {
                   transferBufferToMediaPlayer();

                   // Delete the downloaded File as it's now been transferred to the currently playing buffer file.
                   downloadingMediaFile.delete();
                textStreamed.setText(("Audio full loaded: " + totalKbRead + " Kb read"));
            }
        };
        handler.post(updater);
    }

    public MediaPlayer getMediaPlayer() {
        return mediaPlayer;
    }

    public void startPlayProgressUpdater() {
        float progress = (((float)mediaPlayer.getCurrentPosition()/1000)/mediaLengthInSeconds);
        progressBar.setProgress((int)(progress*100));

        if (mediaPlayer.isPlaying()) {
            Runnable notification = new Runnable() {
                public void run() {
                    startPlayProgressUpdater();
                }
            };
            handler.postDelayed(notification,1000);
        }
    }

    public void interrupt() {
        playButton.setEnabled(false);
        isInterrupted = true;
        validateNotInterrupted();
    }

    /**
     * Move the file in oldLocation to newLocation.
     */
    public void moveFile(File    oldLocation, File    newLocation)
    throws IOException {

        if ( oldLocation.exists( )) {
            BufferedInputStream reader = new BufferedInputStream( new FileInputStream(oldLocation) );
            BufferedOutputStream writer = new BufferedOutputStream( new FileOutputStream(newLocation, false));
            try {
                byte[] buff = new byte[8192];
                int numChars;
                while ( (numChars = reader.read( buff, 0, buff.length ) ) != -1) {
                    writer.write( buff, 0, numChars );
                  }
            } catch( IOException ex ) {
                throw new IOException("IOException when transferring " + oldLocation.getPath() + " to " + newLocation.getPath());
            } finally {
                try {
                    if ( reader != null ){
                        writer.close();
                        reader.close();
                    }
                } catch( IOException ex ){
                    Log.e(getClass().getName(),"Error closing files when transferring " + oldLocation.getPath() + " to " + newLocation.getPath() );
                }
            }
        } else {
            throw new IOException("Old location does not exist when transferring " + oldLocation.getPath() + " to " + newLocation.getPath() );
        }
    }
}

now copy the below code in activity
------------------------------------------
StreamingMediaPlayer audioStreamer = new StreamingMediaPlayer(this,textStreamed, playButton, streamButton,progressBar);
audioStreamer.startStreaming("your streaming station name",5208, 216);

i thins this helps you :)

2012-11-28T07:51:00.000-08:00

Interfacing with pc

Windows XP

Desktop CPU with DB25 Connector

VS 2008 or Update Version
RS232.dll file (Most important)

Basic Socket Programming in C#

2012-09-30T15:57:00.000-07:00

using System;

using System.Text;/* this is server side code to receive data from client and sent data to client*/

using System.Net;

using System.Net.Sockets;

public class serv {

public static void Main() {

try {

IPAddress ipAd = IPAddress.Parse("172.21.5.99");//this ip is server pc local ip

/* Initializes the Listener */

TcpListener myList=new TcpListener(ipAd,8001);

/* Start Listeneting at the specified port */

myList.Start();

Console.WriteLine("The server is running at port 8001...");

Console.WriteLine("The local End point is :" +

myList.LocalEndpoint );

Console.WriteLine("Waiting for a connection.....");

Socket s=myList.AcceptSocket();

Console.WriteLine("Connection accepted from " + s.RemoteEndPoint);

byte[] b=new byte[100];

int k=s.Receive(b);

Console.WriteLine("Recieved...");

for (int i=0;i<k;i++)

Console.Write(Convert.ToChar(b[i]));

ASCIIEncoding asen=new ASCIIEncoding();

/*sent data to client */

s.Send(asen.GetBytes("The string was recieved by the server."));

Console.WriteLine("\nSent Acknowledgement");

/* clean up */

s.Close();

myList.Stop();

}

catch (Exception e) {

Console.WriteLine("Error..... " + e.StackTrace);

}

Client Side code to sent data to server

using System;

using System.IO;

using System.Net;

using System.Text;

using System.Net.Sockets;

public class clnt {

    public static void Main() {

        try {

            TcpClient tcpclnt = new TcpClient();

            Console.WriteLine("Connecting.....");

            tcpclnt.Connect("172.21.5.99",8001);//this ip adress is server pc ip adress

            Console.WriteLine("Connected");

            Console.Write("Enter the string to be transmitted : ");

            String str=Console.ReadLine();

            Stream stm = tcpclnt.GetStream();

            ASCIIEncoding asen= new ASCIIEncoding();

            byte[] ba=asen.GetBytes(str);

            Console.WriteLine("Transmitting.....");

            stm.Write(ba,0,ba.Length);//sent data to server

            byte[] bb=new byte[100];

            int k=stm.Read(bb,0,100);//receive data from server

            for (int i=0;i<k;i++)

                Console.Write(Convert.ToChar(bb[i]));

            tcpclnt.Close();

        catch (Exception e) {

            Console.WriteLine("Error..... " + e.StackTrace);

Greetings from Coding World

2012-09-30T14:20:00.000-07:00

Welcome to the Coding World. Feel free to your coding. Post your problem and get tremendous solution quickly!!!!!!!.

Happy Coding

Mohammad Tanvirul Islam

Android, ,C#, Flex developer