Simulate Netease cloud

How to play music in listview

First, define mediaPlayer in MusicActivity and initialize it in Oncreate method. The path to read the music in the Fragment file and put it into the array

String path=cursor.getString(cursor.getColumnIndex(MediaStore.Audio.Media.DATA));
m.path=path;
Common.musicList.add(m);

Then set the playback source in the pay () method (play is to encapsulate a separate playback method), prepare for playback, and start playing, so that you can play.

  try {
            mediaPlayer.setDataSource(music.path);//Set playback source
            mediaPlayer.prepare();//Player preparation
            mediaPlayer.start();
        } catch (IOException e) {
            e.printStackTrace();  

How to click the previous song, and the next song can be switched and paused

First, bind the ID to the previous and next pictures, set the click and listen events, which need to use the logical relationship if statement to be clear. When you click the previous song of the first song, you need to go back to the last song, click the last song, and you will go back to the first song.

        img2.setOnClickListener(this);
        img3.setOnClickListener(this);
        playbtn.setOnClickListener(this);

 @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.music_img2:
                i--;
                if (i == -1) {
                    i = Common.musicList.size() - 1;
                }
                play();
                break;
            case R.id.music_img3:
                i++;
                if (i == Common.musicList.size()) {
                    i = 0;
                }
                play();
                break;
            case R.id.music_play_btn:
                if (mediaPlayer.isPlaying()) {
                    mediaPlayer.pause();//Music suspended
                    playbtn.setImageResource(R.mipmap.ic_play_btn_play_pressed);
                } else {
                    mediaPlayer.start();//Music begins
                    playbtn.setImageResource(R.mipmap.ic_play_btn_pause);//The picture becomes a pause picture
                }
                break;
        }
    }

Background virtualization of music playing interface

First, create a tool class BlurUtil, and then call it

    private static final String TAG = BlurUtil.class.getSimpleName();

    /**
     * Ground glass the picture
     * @param sentBitmap bitmap
     * @param radius Degree of emptiness
     * @param canReuseInBitmap Reuse
     * @return bitmap
     */
    public static Bitmap doBlur(Bitmap sentBitmap, int radius, boolean canReuseInBitmap) {

        Bitmap bitmap;
        if (canReuseInBitmap) {
            bitmap = sentBitmap;
        } else {
            bitmap = sentBitmap.copy(sentBitmap.getConfig(), true);
        }

        if (radius < 1) {
            return (null);
        }

        int w = bitmap.getWidth();
        int h = bitmap.getHeight();

        int[] pix = new int[w * h];
        bitmap.getPixels(pix, 0, w, 0, 0, w, h);

        int wm = w - 1;
        int hm = h - 1;
        int wh = w * h;
        int div = radius + radius + 1;

        int r[] = new int[wh];
        int g[] = new int[wh];
        int b[] = new int[wh];
        int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
        int vmin[] = new int[Math.max(w, h)];

        int divsum = (div + 1) >> 1;
        divsum *= divsum;
        int dv[] = new int[256 * divsum];
        for (i = 0; i < 256 * divsum; i++) {
            dv[i] = (i / divsum);
        }

        yw = yi = 0;

        int[][] stack = new int[div][3];
        int stackpointer;
        int stackstart;
        int[] sir;
        int rbs;
        int r1 = radius + 1;
        int routsum, goutsum, boutsum;
        int rinsum, ginsum, binsum;

        for (y = 0; y < h; y++) {
            rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
            for (i = -radius; i <= radius; i++) {
                p = pix[yi + Math.min(wm, Math.max(i, 0))];
                sir = stack[i + radius];
                sir[0] = (p & 0xff0000) >> 16;
                sir[1] = (p & 0x00ff00) >> 8;
                sir[2] = (p & 0x0000ff);
                rbs = r1 - Math.abs(i);
                rsum += sir[0] * rbs;
                gsum += sir[1] * rbs;
                bsum += sir[2] * rbs;
                if (i > 0) {
                    rinsum += sir[0];
                    ginsum += sir[1];
                    binsum += sir[2];
                } else {
                    routsum += sir[0];
                    goutsum += sir[1];
                    boutsum += sir[2];
                }
            }
            stackpointer = radius;

            for (x = 0; x < w; x++) {

                r[yi] = dv[rsum];
                g[yi] = dv[gsum];
                b[yi] = dv[bsum];

                rsum -= routsum;
                gsum -= goutsum;
                bsum -= boutsum;

                stackstart = stackpointer - radius + div;
                sir = stack[stackstart % div];

                routsum -= sir[0];
                goutsum -= sir[1];
                boutsum -= sir[2];

                if (y == 0) {
                    vmin[x] = Math.min(x + radius + 1, wm);
                }
                p = pix[yw + vmin[x]];

                sir[0] = (p & 0xff0000) >> 16;
                sir[1] = (p & 0x00ff00) >> 8;
                sir[2] = (p & 0x0000ff);

                rinsum += sir[0];
                ginsum += sir[1];
                binsum += sir[2];

                rsum += rinsum;
                gsum += ginsum;
                bsum += binsum;

                stackpointer = (stackpointer + 1) % div;
                sir = stack[(stackpointer) % div];

                routsum += sir[0];
                goutsum += sir[1];
                boutsum += sir[2];

                rinsum -= sir[0];
                ginsum -= sir[1];
                binsum -= sir[2];

                yi++;
            }
            yw += w;
        }
        for (x = 0; x < w; x++) {
            rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
            yp = -radius * w;
            for (i = -radius; i <= radius; i++) {
                yi = Math.max(0, yp) + x;

                sir = stack[i + radius];

                sir[0] = r[yi];
                sir[1] = g[yi];
                sir[2] = b[yi];

                rbs = r1 - Math.abs(i);

                rsum += r[yi] * rbs;
                gsum += g[yi] * rbs;
                bsum += b[yi] * rbs;

                if (i > 0) {
                    rinsum += sir[0];
                    ginsum += sir[1];
                    binsum += sir[2];
                } else {
                    routsum += sir[0];
                    goutsum += sir[1];
                    boutsum += sir[2];
                }

                if (i < hm) {
                    yp += w;
                }
            }
            yi = x;
            stackpointer = radius;
            for (y = 0; y < h; y++) {
                // Preserve alpha channel: ( 0xff000000 & pix[yi] )
                pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum];

                rsum -= routsum;
                gsum -= goutsum;
                bsum -= boutsum;

                stackstart = stackpointer - radius + div;
                sir = stack[stackstart % div];

                routsum -= sir[0];
                goutsum -= sir[1];
                boutsum -= sir[2];

                if (x == 0) {
                    vmin[y] = Math.min(y + r1, hm) * w;
                }
                p = x + vmin[y];

                sir[0] = r[p];
                sir[1] = g[p];
                sir[2] = b[p];

                rinsum += sir[0];
                ginsum += sir[1];
                binsum += sir[2];

                rsum += rinsum;
                gsum += ginsum;
                bsum += binsum;

                stackpointer = (stackpointer + 1) % div;
                sir = stack[stackpointer];

                routsum += sir[0];
                goutsum += sir[1];
                boutsum += sir[2];

                rinsum -= sir[0];
                ginsum -= sir[1];
                binsum -= sir[2];

                yi += w;
            }
        }

        bitmap.setPixels(pix, 0, w, 0, 0, w, h);

//        print("after virtualization", bitmap);
        return (bitmap);
    }

    /**
     * Ground glass the picture
     * @param originBitmap bitmap
     * @param scaleRatio Zoom ratio
     * @param blurRadius Ground glass ratio
     * @return bitmap
     */
    public static Bitmap doBlur(Bitmap originBitmap, int scaleRatio, int blurRadius){
//        print("original image::", originBitmap);
        Bitmap scaledBitmap = Bitmap.createScaledBitmap(originBitmap,
                originBitmap.getWidth() / scaleRatio,
                originBitmap.getHeight() / scaleRatio,
                false);
        Bitmap blurBitmap = doBlur(scaledBitmap, blurRadius, false);
        scaledBitmap.recycle();
        return blurBitmap;
    }

    /**
     * Ground glass image
     * @param originBitmap bitmap
     * @param width Desired width after scaling
     * @param height Desired height after scaling
     * @param blurRadius Degree of emptiness
     * @return bitmap
     */
    public static Bitmap doBlur(Bitmap originBitmap,int width,int height,int blurRadius){
        Bitmap thumbnail = ThumbnailUtils.extractThumbnail(originBitmap, width, height);
        Bitmap blurBitmap = doBlur(thumbnail, blurRadius, true);
        thumbnail.recycle();
        return blurBitmap;
    }
}
//Call the doBlur method in BlurUtil directly.
Bitmap bgbm = BlurUtil.doBlur(music.thumbBitmap,10,5);

Disc and music picture synthesis

Tags: MediaPlayer Fragment

Posted on Wed, 01 Apr 2020 23:24:31 -0700 by rayner75