音乐播放器

 

 

package com.tan.lyc;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URLEncoder;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import com.tan.myplay.MyApplication;
import com.tan.service.MusicPlayService;

import android.content.IntentSender.SendIntentException;
import android.util.Log;

public class LrcProcess {
    private String url = "http://geci.me/api/lyric/";
    private List<LrcContent> lrcList; // List集合存放歌词内容对象
    private LrcContent mLrcContent; // 声明一个歌词内容对象
    private String lrc;
    private ByteArrayOutputStream out;
    private String songname, singer;

    /**
     * 无参构造函数用来实例化对象
     */
    public LrcProcess() {
        mLrcContent = new LrcContent();
        lrcList = new ArrayList<LrcContent>();
    }

    /**
     * 读取歌词
     * 
     * @param path
     * @param songname
     * @param singer
     * @return
     */
    public String readLRC(String path, String singer, String songname) {
        // 定义一个StringBuilder对象，用来存放歌词内容
        StringBuilder stringBuilder = new StringBuilder();
        String s1 = path.substring(0, path.length() - 4);
        s1 += ".lrc";
        Log.d("test", s1 + "           path");
        Log.d("test","please tell me ok");
        File f = new File(s1);
        // System.out.println(path);
        try {
            FileInputStream fis = new FileInputStream(f);
            InputStreamReader isr = new InputStreamReader(fis, "utf-8");
            BufferedReader br = new BufferedReader(isr);
            String s = "";
            while ((s = br.readLine()) != null) {
                s = s.replace("[", "");
                s = s.replace("]", "@"); // 每一句话的分隔符

                s = s.replaceAll("<[0-9]{3,5}>", ""); // 去掉每个字的时间标签,这里用到了正则表达式

                String spiltLrcData[] = s.split("@");

                if (spiltLrcData.length > 1) {

                    mLrcContent.setLrcStr(spiltLrcData[1]); // 将每句话创建一个类的实例,歌词和对应时间赋值
                    int lycTime = time2Str(spiltLrcData[0]);
                    mLrcContent.setLrcTime(lycTime);
                    lrcList.add(mLrcContent);

                    mLrcContent = new LrcContent();
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            // Log.d("test", "findlrc");
//             findLrc(path, songname, singer);
            // Log.d("test", "why not");
            test(path,songname, singer);
            // readLRC(path, songname, singer);
            stringBuilder.append("一丁点儿歌词都没找到,下载后再来找我把.......");
        } catch (Exception e) {
            e.printStackTrace();
            stringBuilder.append("没有读取到歌词.....");
        }
        return stringBuilder.toString();
    }

    private void test(final String path,final String songname, final String singer) {
        out = new ByteArrayOutputStream();
        new Thread() {
            public void run() {
                String url = null;
                try {
                    url = setParams(songname, singer);
                } catch (UnsupportedEncodingException e1) {
                    
                    e1.printStackTrace();
                }
                try {
                    URL url1 = new URL(url);
                    HttpURLConnection conn = (HttpURLConnection) url1
                            .openConnection();
                    InputStream in = conn.getInputStream();
                    byte[] data = new byte[1024];
                    int len = 0;

                    while ((len = in.read(data)) != -1) {
                        Log.d("test", data + "data");
                        out.write(data, 0, len);
                    }
                    out.flush();
                    
                    String json=new String(out.toByteArray());
                    Log.d("test", new String(out.toByteArray()));
                    
                    JSONObject jsonObject = null;
                    try {
                        jsonObject = new JSONObject(json);
                    } catch (JSONException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                    }
                    int count = 0;
                    try {
                        count = jsonObject.getInt("count");
                    } catch (JSONException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    Log.d("count", count + "");
                    JSONArray array = null;
                    try {
                        array = jsonObject.getJSONArray("result");
                    } catch (JSONException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    try {
                        lrc = array.getJSONObject(0).getString("lrc");
                    } catch (JSONException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    
                    URL url2 = new URL(lrc);
                    InputStream in1 = url2.openStream();
                    BufferedReader reader = new BufferedReader(
                            new InputStreamReader(in1));
                    String s1 = path.substring(0, path.length() - 4);
                    s1 += ".lrc";
                
                    Log.d("test",s1+"file path");
                    File file = new File(s1);
                    // FileOutputStream fout=new FileOutputStream(file);
                    FileWriter fw = new FileWriter(file);
                    String s = "";
                    while ((s = reader.readLine()) != null) {
                        fw.write(s+"\n");
                        Log.d("test", s);
                    }
                    fw.close();

                } catch (MalformedURLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }.start();

    }

    private void findLrc(final String path, String songname, String singer) {

        String json = getJson(songname, singer);

        Log.d("test", json + "json");
        String lrc = analysis(json);
        Log.d("test", lrc + "lrc");
        makeFile(lrc, path);

    }

    protected void makeFile(final String lrc, final String path) {
        new Thread() {
            public void run() {
                try {
                    URL url1 = new URL(lrc);
                    InputStream in = url1.openStream();
                    BufferedReader reader = new BufferedReader(
                            new InputStreamReader(in));
                    String s1 = path.substring(0, path.length() - 4);
                    s1 += ".lrc";
                    int len = -1;
                    File file = new File(s1);
                    // FileOutputStream fout=new FileOutputStream(file);
                    FileWriter fw = new FileWriter(file);
                    String s = "";
                    while ((s = reader.readLine()) != null) {
                        fw.write(s);
                        Log.d("test", s);
                    }
                    fw.close();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            };
        }.start();
    }

    protected String analysis(final String json) {
        new Thread() {
            public void run() {
                try {
                    JSONObject jsonObject = new JSONObject(json);
                    int count = jsonObject.getInt("count");
                    Log.d("count", count + "");
                    JSONArray array = jsonObject.getJSONArray("result");
                    lrc = array.getJSONObject(0).getString("lrc");
                    Log.d("test", "lrc  dhajdjhaj" + lrc);
                    // 获取到lrc地址
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }.start();
        return lrc;
    }

    private String getJson(final String songname,final String singer) {
        out = new ByteArrayOutputStream();
        new Thread() {
            public void run() {
                InputStream inStream = null;
                String url = null;
                URL urlLrc = null;
                try {
                    url = setParams(songname, singer);
                } catch (UnsupportedEncodingException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                try {
                    urlLrc = new URL(url);
                } catch (MalformedURLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                Log.d("test", urlLrc + "");
                byte[] data = new byte[1024];
                int len = 0;
                HttpURLConnection conn = null;
                try {
                    conn = (HttpURLConnection) urlLrc.openConnection();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                try {
                    conn.setRequestMethod("GET");
                } catch (ProtocolException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }// 使用GET方法获取
                conn.setConnectTimeout(5000);
                Log.d("test", "conn" + conn);
                try {
                    conn.connect();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                try {
                    inStream = conn.getInputStream();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                Log.d("test", inStream + "instream");
                try {
                    while ((len = inStream.read(data)) != -1) {
                        Log.d("test", data + "data");
                        out.write(data, 0, len);
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                try {
                    out.flush();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                Log.d("test", data.toString());
                try {
                    inStream.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                try {
                    out.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //
            }
        }.start();
        return new String(out.toByteArray());
    }

    private String setParams(String songname, String singer)
            throws UnsupportedEncodingException {
        String song = URLEncoder.encode(songname, "UTF-8");
        String sing = URLEncoder.encode(singer, "UTF-8");
        return url + song + "/" + sing;
    }

    private void createFile(String path, String songname, String singer) {

    }

    public int TimeStr(String timeStr) {

        timeStr = timeStr.replace(":", ".");
        timeStr = timeStr.replace(".", "@");

        String timeData[] = timeStr.split("@");

        // 分离出分、秒并转换为整型
        int minute = Integer.parseInt(timeData[0]);
        int second = Integer.parseInt(timeData[1]);
        int millisecond = Integer.parseInt(timeData[2]);

        // 计算上一行与下一行的时间转换为毫秒数
        int currentTime = (minute * 60 + second) * 1000 + millisecond * 10;

        return currentTime;
    }

    /**
     * 解析歌词时间 歌词内容格式如下： [00:02.32]陈奕迅 [00:03.43]好久不见 [00:05.22]歌词制作 王涛
     * 
     * @param timeStr
     * @return
     */
    public int time2Str(String timeStr) { // 将分:秒:毫秒转化为长整型的数
        timeStr = timeStr.replace(":", ".");
        timeStr = timeStr.replace(".", "@");

        String timeData[] = timeStr.split("@");

        int min = Integer.parseInt(timeData[0]);
        int sec = Integer.parseInt(timeData[1]);
        int millSec = Integer.parseInt(timeData[2]);

        int currentTime = (min * 60 + sec) * 1000 + millSec * 10;
        return currentTime;
    }

    public List<LrcContent> getLrcList() {
        return lrcList;
    }

}

url需要utf-8转换

否则得不到的对应的数据，既找不到对应的url

其中如果找不到歌词会在歌词迷上搜索并下载

package com.tan.sortadapter;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import com.tan.bean.Music;
import com.tan.myplay.R;

import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.provider.MediaStore;
import android.provider.MediaStore.Audio;
import android.provider.MediaStore.Images;
import android.util.Log;

public class ReadDataFromContentProvider {

    /*
     * 读取所有图片
     */
    public static void readImage(Context context) {
        ContentResolver resolver = context.getContentResolver();
        Uri imgUri = Images.Media.EXTERNAL_CONTENT_URI;
        String[] columns = new String[] { Images.Media.TITLE,
                Images.Media.DATA, Images.Media.SIZE, Images.Media.MIME_TYPE // 类型
        };
        Cursor cursor = resolver.query(imgUri, columns, null, null, null);

        if (null != cursor && cursor.getCount() > 0) {
            while (cursor.moveToNext()) {
                Log.e("imgs", cursor.getString(0) + "\t" + cursor.getString(3));
            }
        }
        if (null != cursor) {
            cursor.close();
        }
    }

    public static List<Music> readAudio(Context context) {
        ContentResolver resolver = context.getContentResolver();
        System.out.println("recovetsk mkahn i");
        Uri audioUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
        String[] columns = { Audio.Media.TITLE, // 歌名
                MediaStore.Audio.Media.DATA, // 路径
                MediaStore.Audio.Media.ARTIST, // 演唱者
                MediaStore.Audio.Media.ALBUM, // 专辑名
                MediaStore.Audio.Media.DURATION, // 音频文件长度，毫秒
                MediaStore.Audio.Media.ALBUM_KEY// 用来读取专辑图片时使用
        };
        List<Music> data = null;
        Cursor cursor = resolver.query(audioUri, columns, null,null, null);
//        System.out.println("query mkahn i");
//        System.out.println(cursor.getCount()+"nbdajbvdjha");
        if (null != cursor && cursor.getCount() > 0) {
            data = new ArrayList<Music>();
//            System.out.println("cursor is nou null");
            CharacterParser characterParser = CharacterParser.getInstance();
            while (cursor.moveToNext()) {
                // 读到一个音频
                // 读取该音频的专辑图片信息
//                System.out.println("find data");
                
                // Uri albumUri = Audio.Albums.EXTERNAL_CONTENT_URI;
                // Cursor albumCursor = resolver.query(albumUri, new
                // String[]{Audio.Albums.ALBUM_ART}, Audio.Albums.ALBUM_KEY
                // +"=?", new String[]{albumKey}, null) ;
                // if(albumCursor != null && albumCursor.getCount() > 0) {
                // albumCursor.moveToNext() ;
//                String albumPath = albumCursor.getString(0);
                // bmp = BitmapFactory.decodeFile(albumPath) ;
                // albumCursor.close() ;
                // }
                long albumKey=cursor.getLong(5);
                String album_uri = "content://media/external/audio/albumart"; // 专辑Uri对应的字符串
                Uri albumUri = ContentUris.withAppendedId(Uri.parse(album_uri),
                        albumKey);
                // 取图片 ==> 得到一个输入流
                Bitmap bim = null;
                try {
                    InputStream is = context.getContentResolver()
                            .openInputStream(albumUri);
                    System.out.println("is inputstream");
                    if (null != is) {
                        System.out.println("is not null inputstream");
                        bim = BitmapFactory.decodeStream(is);
                    }
                    else{
                        bim=BitmapFactory.decodeResource(context.getResources(), R.drawable.bc1);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
        
             
                String songname = cursor.getString(0);
                String url = cursor.getString(1);
                String singer = cursor.getString(2);
                String belongto = cursor.getString(3);
                Long duration = cursor.getLong(4);
                
                // Bitmap bitmap=bmp;
                String pinyin = characterParser.getSelling(songname);
                String sortString = pinyin.substring(0, 1).toUpperCase();
                String sortLetter;
                // 正则表达式，判断首字母是否是英文字母
                if (sortString.matches("[A-Z]")) {
                    sortLetter = sortString.toUpperCase();
                } else {
                    sortLetter = "#";
                }
                Music music = new Music(url, songname, singer, sortLetter,
                        belongto, duration,bim);
                data.add(music);
                // System.out.println(music);

                // data.add(new Music(cursor.getString(0), cursor.getString(1),
                // cursor.getString(2), cursor.getString(3) , cursor.getLong(4)
                // , bmp)) ;
            }
        }
        if (null != cursor) {
            cursor.close();
        }
        return data;
    }
    
//    private static String getAlbumArt(Context context,int album_id) {  
//        String mUriAlbums = "content://media/external/audio/albums";  
//        String[] projection = new String[] { "album_art" };  
//        Cursor cur = context.getContentResolver().query(  
//                Uri.parse(mUriAlbums + "/" + Integer.toString(album_id)),  
//                projection, null, null, null);  
//        String album_art = null;  
//        if (cur.getCount() > 0 && cur.getColumnCount() > 0) {  
//            cur.moveToNext();  
//            album_art = cur.getString(0);  
//        }  
//        cur.close();  
//        cur = null;  
//        return album_art;  
//    } 
}

从contentprovider中读取本机音乐信息并用music封装

package com.tan.bean;

import android.graphics.Bitmap;

public class Music {
    private String url;
    private String songName;
    private String singer;
    private String sortLetters;
    private String belongto;
    private Long duration;
    private Bitmap bitmap;
    /*
     * sortLetters 与 songName 相匹配
     * 也可扩展成能跟singer匹配
     */
    
    public Music() {
        super();
    }

    
    public Music( String url, String songName, String singer,
            String sortLetters, String belongto, Long duration) {
        super();
        this.url = url;
        this.songName = songName;
        this.singer = singer;
        this.sortLetters = sortLetters;
        this.belongto = belongto;
        this.duration = duration;
    }


    


    public Music(String url, String songName, String singer,
            String sortLetters, String belongto, Long duration, Bitmap bitmap) {
        super();
        this.url = url;
        this.songName = songName;
        this.singer = singer;
        this.sortLetters = sortLetters;
        this.belongto = belongto;
        this.duration = duration;
        this.bitmap = bitmap;
    }


    @Override
    public String toString() {
        return "Music [url=" + url + ", songName=" + songName + ", singer="
                + singer + ", sortLetters=" + sortLetters + ", belongto="
                + belongto + ", duration=" + duration 
                + "]";
    }


    public String getBelongto() {
        return belongto;
    }


    public void setBelongto(String belongto) {
        this.belongto = belongto;
    }


    public Long getDuration() {
        return duration;
    }

    public void setDuration(Long duration) {
        this.duration = duration;
    }

    public Bitmap getBitmap() {
        return bitmap;
    }

    public void setBitmap(Bitmap bitmap) {
        this.bitmap = bitmap;
    }

    public String getSortLetters() {
        return sortLetters;
    }

    public void setSortLetters(String sortLetters) {
        this.sortLetters = sortLetters;
    }

    

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getSongName() {
        return songName;
    }

    public void setSongName(String songName) {
        this.songName = songName;
    }

    public String getSinger() {
        return singer;
    }

    public void setSinger(String singer) {
        this.singer = singer;
    }

}

音乐的存放

实现Parcelable就是为了进行序列化

永久性保存对象，保存对象的字节序列到本地文件中；

通过序列化对象在网络中传递对象；

通过序列化在进程间传递对象。

package com.tan.lyc;

public class LrcContent {  
    private String lrcStr;  //歌词内容  
    private long lrcTime;    //歌词当前时间  
    public String getLrcStr() {  
        return lrcStr;  
    }  
    public void setLrcStr(String lrcStr) {  
        this.lrcStr = lrcStr;  
    }  
    public long getLrcTime() {  
        return lrcTime;  
    }  
    public void setLrcTime(long lrcTime) {  
        this.lrcTime = lrcTime;  
    }
    
}  

存放歌词信息 即时间加字段

package com.tan.lyc;

import java.util.ArrayList;
import java.util.List;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.widget.TextView;


/**
 * 类说明：自定义绘画歌词，产生滚动效果
 */

public class LrcView extends TextView {

    private float width;
    private float high;
    private Paint CurrentPaint;
    private Paint NotCurrentPaint;
    private float TextHigh = 60;
    private float TextSize = 30;
    private int Index = 0;

    private List<LrcContent> mSentenceEntities = new ArrayList<LrcContent>();

    public void setSentenceEntities(List<LrcContent> mSentenceEntities) {
        this.mSentenceEntities = mSentenceEntities;
    }

    public LrcView(Context context) {
        super(context);
        init();
    }

    public LrcView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
    }

    public LrcView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    private void init() {
        setFocusable(true);

        // 高亮部分
        CurrentPaint = new Paint();
        CurrentPaint.setAntiAlias(true);
        CurrentPaint.setTextAlign(Paint.Align.CENTER);

        // 非高亮部分
        NotCurrentPaint = new Paint();
        NotCurrentPaint.setAntiAlias(true);
        NotCurrentPaint.setTextAlign(Paint.Align.CENTER);
    }

    @Override
    public void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        if (canvas == null) {
            return;
        }

        CurrentPaint.setColor(Color.argb(210, 251, 248, 29));
        NotCurrentPaint.setColor(Color.argb(140, 255, 255, 255));

        CurrentPaint.setTextSize(45);
        CurrentPaint.setTypeface(Typeface.SERIF);

        NotCurrentPaint.setTextSize(TextSize);
        NotCurrentPaint.setTypeface(Typeface.DEFAULT);

        try {
            setText("");
            canvas.drawText(mSentenceEntities.get(Index).getLrcStr(), width / 2,
                    high / 2, CurrentPaint);

            float tempY = high / 2;
            // 画出本句之前的句子
            for (int i = Index - 1; i >= 0; i--) {
                // 向上推移
                tempY = tempY - TextHigh;

                canvas.drawText(mSentenceEntities.get(i).getLrcStr(), width / 2,
                        tempY, NotCurrentPaint);
            }
            tempY = high / 2;
            // 画出本句之后的句子
            for (int i = Index + 1; i < mSentenceEntities.size(); i++) {
                // 往下推移
                tempY = tempY + TextHigh;
                canvas.drawText(mSentenceEntities.get(i).getLrcStr(), width / 2,
                        tempY, NotCurrentPaint);
            }
        } catch (Exception e) {
            setText("木有歌词文件，赶紧去下载吧...");
        }
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);

        this.width = w;
        this.high = h;
    }

    public void SetIndex(int index) {
        this.Index = index;
    }
}

ondraw方法用来实现歌词的滚动

package com.tan.service;

import com.tan.myplay.MainActivity;
import com.tan.myplay.MusicPlayActivity;
import com.tan.myplay.MyApplication;
import com.tan.myplay.NotiReceiver;
import com.tan.myplay.R;
import com.tan.service.MusicPlayService.LocalBinder;

import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Binder;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.util.Log;
import android.widget.RemoteViews;

public class NotiService extends Service {

    private NotificationManager notificationManager;
    private Notification notification;
    private MusicPlayService service;
    private Handler handler;
    private Context context;
    private final IBinder mBinder = new LocalBinder1();
    
    public NotiService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    public class LocalBinder1 extends Binder {
        public NotiService getService() {
            return NotiService.this;
        }
    }
    @Override
    public void onCreate() {
        MyApplication application = (MyApplication) getApplication();
        service = application.getmService();
        handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                Bundle bundle = msg.getData();
                String action = bundle.getString("action");
                if (action.equals(MainActivity.lastAction)) {
                    service.setCurrentTime(0);
                    service.frontMusic();

                } else if (action.equals(MainActivity.nextAction)) {
                    service.setCurrentTime(0);
                    service.nextMusic();

                } else if (action.equals(MainActivity.playAction)) {
                    service.pausePlay();
                }else if(action.equals(MainActivity.startAction)){
                    service.playMusic();
                }
            
                initNotification();
            }
        };
//        System.out.println("handler ok");

        NotiReceiver notiReceiver = new NotiReceiver(handler);
        IntentFilter fil = new IntentFilter();
        fil.addAction(MainActivity.nextAction);
        fil.addAction(MainActivity.playAction);
        fil.addAction(MainActivity.lastAction);
        fil.addAction(MainActivity.startAction);
        registerReceiver(notiReceiver, fil);
//        System.out.println("register ok");
        initNotification();
//        System.out.println("error here");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // TODO Auto-generated method stub
        initNotification();
        return super.onStartCommand(intent, flags, startId);
    }

    

    private void initNotification() {
        Log.d("test", "start hkahkfhkahfkhajfkjafahn");
        notification = new Notification(R.drawable.ic_launcher, "lose音乐",
                System.currentTimeMillis());
        notificationManager = (NotificationManager) getSystemService(getApplicationContext().NOTIFICATION_SERVICE);
        // 设置不消失（应用没退出的话）
        notification.flags = Notification.FLAG_ONGOING_EVENT;
        RemoteViews contentViews = new RemoteViews(getPackageName(),
                R.layout.notification);

        contentViews.setImageViewResource(R.id.noti_showlyric,
                R.drawable.ic_launcher);

        contentViews.setTextViewText(R.id.noti_songname, service.getSongName());
        contentViews.setTextViewText(R.id.noti_songsinger, service.getSingerName());

        contentViews.setImageViewResource(R.id.noti_lastsong,
                R.drawable.latest1);
        contentViews.setImageViewResource(R.id.noti_nextsong, R.drawable.next1);

        Log.d("test", "start dadljalhdkahk initno");
        if(service.isPlay()){
        contentViews.setImageViewResource(R.id.noti_playbt,
                    R.drawable.pause1);
        }else{
            contentViews.setImageViewResource(R.id.noti_playbt,
                    R.drawable.play1);
        }
        
        Log.d("test","servieces error");
        notification.contentView = contentViews;

        Intent previousButtonIntent = new Intent(MainActivity.lastAction);
        PendingIntent pendPreviousButtonIntent = PendingIntent.getBroadcast(
                this, 0, previousButtonIntent, 0);
        contentViews.setOnClickPendingIntent(R.id.noti_lastsong,
                pendPreviousButtonIntent);

        Intent nextButtonIntent = new Intent(MainActivity.nextAction);
        PendingIntent pendNextButtonIntent = PendingIntent.getBroadcast(this,
                0, nextButtonIntent, 0);
        contentViews.setOnClickPendingIntent(R.id.noti_nextsong,
                pendNextButtonIntent);

        Intent playButtonIntent = new Intent(MainActivity.playAction);
        PendingIntent pendPlayButtonIntent = PendingIntent.getBroadcast(this,
                0, playButtonIntent, 0);
        contentViews.setOnClickPendingIntent(R.id.noti_playbt,
                pendPlayButtonIntent);

        Intent notificationIntent = new Intent(this, MainActivity.class);
        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
                notificationIntent, 0);
        notification.contentIntent = contentIntent;
        notificationManager.notify(0, notification);
        Log.d("test", "adadad.la initno");
    }
    
    public void setContext(Context context) {
        this.context = context;
    }


}

应用退出后，能够继续响应通知点击事件

/*
 * Filename    CharacterParser.java
 * Company    上海乐问-浦东分公司。
 * @author    LuRuihui
 * @version    0.1
 */
package com.tan.sortadapter;

/**
 * Java汉字转换为拼音
 * 
 */
public class CharacterParser {
    private static int[] pyvalue = new int[] {-20319, -20317, -20304, -20295, -20292, -20283, -20265, -20257, -20242, -20230, -20051, -20036, -20032,
            -20026, -20002, -19990, -19986, -19982, -19976, -19805, -19784, -19775, -19774, -19763, -19756, -19751, -19746, -19741, -19739, -19728,
            -19725, -19715, -19540, -19531, -19525, -19515, -19500, -19484, -19479, -19467, -19289, -19288, -19281, -19275, -19270, -19263, -19261,
            -19249, -19243, -19242, -19238, -19235, -19227, -19224, -19218, -19212, -19038, -19023, -19018, -19006, -19003, -18996, -18977, -18961,
            -18952, -18783, -18774, -18773, -18763, -18756, -18741, -18735, -18731, -18722, -18710, -18697, -18696, -18526, -18518, -18501, -18490,
            -18478, -18463, -18448, -18447, -18446, -18239, -18237, -18231, -18220, -18211, -18201, -18184, -18183, -18181, -18012, -17997, -17988,
            -17970, -17964, -17961, -17950, -17947, -17931, -17928, -17922, -17759, -17752, -17733, -17730, -17721, -17703, -17701, -17697, -17692,
            -17683, -17676, -17496, -17487, -17482, -17468, -17454, -17433, -17427, -17417, -17202, -17185, -16983, -16970, -16942, -16915, -16733,
            -16708, -16706, -16689, -16664, -16657, -16647, -16474, -16470, -16465, -16459, -16452, -16448, -16433, -16429, -16427, -16423, -16419,
            -16412, -16407, -16403, -16401, -16393, -16220, -16216, -16212, -16205, -16202, -16187, -16180, -16171, -16169, -16158, -16155, -15959,
            -15958, -15944, -15933, -15920, -15915, -15903, -15889, -15878, -15707, -15701, -15681, -15667, -15661, -15659, -15652, -15640, -15631,
            -15625, -15454, -15448, -15436, -15435, -15419, -15416, -15408, -15394, -15385, -15377, -15375, -15369, -15363, -15362, -15183, -15180,
            -15165, -15158, -15153, -15150, -15149, -15144, -15143, -15141, -15140, -15139, -15128, -15121, -15119, -15117, -15110, -15109, -14941,
            -14937, -14933, -14930, -14929, -14928, -14926, -14922, -14921, -14914, -14908, -14902, -14894, -14889, -14882, -14873, -14871, -14857,
            -14678, -14674, -14670, -14668, -14663, -14654, -14645, -14630, -14594, -14429, -14407, -14399, -14384, -14379, -14368, -14355, -14353,
            -14345, -14170, -14159, -14151, -14149, -14145, -14140, -14137, -14135, -14125, -14123, -14122, -14112, -14109, -14099, -14097, -14094,
            -14092, -14090, -14087, -14083, -13917, -13914, -13910, -13907, -13906, -13905, -13896, -13894, -13878, -13870, -13859, -13847, -13831,
            -13658, -13611, -13601, -13406, -13404, -13400, -13398, -13395, -13391, -13387, -13383, -13367, -13359, -13356, -13343, -13340, -13329,
            -13326, -13318, -13147, -13138, -13120, -13107, -13096, -13095, -13091, -13076, -13068, -13063, -13060, -12888, -12875, -12871, -12860,
            -12858, -12852, -12849, -12838, -12831, -12829, -12812, -12802, -12607, -12597, -12594, -12585, -12556, -12359, -12346, -12320, -12300,
            -12120, -12099, -12089, -12074, -12067, -12058, -12039, -11867, -11861, -11847, -11831, -11798, -11781, -11604, -11589, -11536, -11358,
            -11340, -11339, -11324, -11303, -11097, -11077, -11067, -11055, -11052, -11045, -11041, -11038, -11024, -11020, -11019, -11018, -11014,
            -10838, -10832, -10815, -10800, -10790, -10780, -10764, -10587, -10544, -10533, -10519, -10331, -10329, -10328, -10322, -10315, -10309,
            -10307, -10296, -10281, -10274, -10270, -10262, -10260, -10256, -10254};
    public static String[] pystr = new String[] {"a", "ai", "an", "ang", "ao", "ba", "bai", "ban", "bang", "bao", "bei", "ben", "beng", "bi", "bian",
            "biao", "bie", "bin", "bing", "bo", "bu", "ca", "cai", "can", "cang", "cao", "ce", "ceng", "cha", "chai", "chan", "chang", "chao", "che",
            "chen", "cheng", "chi", "chong", "chou", "chu", "chuai", "chuan", "chuang", "chui", "chun", "chuo", "ci", "cong", "cou", "cu", "cuan",
            "cui", "cun", "cuo", "da", "dai", "dan", "dang", "dao", "de", "deng", "di", "dian", "diao", "die", "ding", "diu", "dong", "dou", "du",
            "duan", "dui", "dun", "duo", "e", "en", "er", "fa", "fan", "fang", "fei", "fen", "feng", "fo", "fou", "fu", "ga", "gai", "gan", "gang",
            "gao", "ge", "gei", "gen", "geng", "gong", "gou", "gu", "gua", "guai", "guan", "guang", "gui", "gun", "guo", "ha", "hai", "han", "hang",
            "hao", "he", "hei", "hen", "heng", "hong", "hou", "hu", "hua", "huai", "huan", "huang", "hui", "hun", "huo", "ji", "jia", "jian",
            "jiang", "jiao", "jie", "jin", "jing", "jiong", "jiu", "ju", "juan", "jue", "jun", "ka", "kai", "kan", "kang", "kao", "ke", "ken",
            "keng", "kong", "kou", "ku", "kua", "kuai", "kuan", "kuang", "kui", "kun", "kuo", "la", "lai", "lan", "lang", "lao", "le", "lei", "leng",
            "li", "lia", "lian", "liang", "liao", "lie", "lin", "ling", "liu", "long", "lou", "lu", "lv", "luan", "lue", "lun", "luo", "ma", "mai",
            "man", "mang", "mao", "me", "mei", "men", "meng", "mi", "mian", "miao", "mie", "min", "ming", "miu", "mo", "mou", "mu", "na", "nai",
            "nan", "nang", "nao", "ne", "nei", "nen", "neng", "ni", "nian", "niang", "niao", "nie", "nin", "ning", "niu", "nong", "nu", "nv", "nuan",
            "nue", "nuo", "o", "ou", "pa", "pai", "pan", "pang", "pao", "pei", "pen", "peng", "pi", "pian", "piao", "pie", "pin", "ping", "po", "pu",
            "qi", "qia", "qian", "qiang", "qiao", "qie", "qin", "qing", "qiong", "qiu", "qu", "quan", "que", "qun", "ran", "rang", "rao", "re",
            "ren", "reng", "ri", "rong", "rou", "ru", "ruan", "rui", "run", "ruo", "sa", "sai", "san", "sang", "sao", "se", "sen", "seng", "sha",
            "shai", "shan", "shang", "shao", "she", "shen", "sheng", "shi", "shou", "shu", "shua", "shuai", "shuan", "shuang", "shui", "shun",
            "shuo", "si", "song", "sou", "su", "suan", "sui", "sun", "suo", "ta", "tai", "tan", "tang", "tao", "te", "teng", "ti", "tian", "tiao",
            "tie", "ting", "tong", "tou", "tu", "tuan", "tui", "tun", "tuo", "wa", "wai", "wan", "wang", "wei", "wen", "weng", "wo", "wu", "xi",
            "xia", "xian", "xiang", "xiao", "xie", "xin", "xing", "xiong", "xiu", "xu", "xuan", "xue", "xun", "ya", "yan", "yang", "yao", "ye", "yi",
            "yin", "ying", "yo", "yong", "you", "yu", "yuan", "yue", "yun", "za", "zai", "zan", "zang", "zao", "ze", "zei", "zen", "zeng", "zha",
            "zhai", "zhan", "zhang", "zhao", "zhe", "zhen", "zheng", "zhi", "zhong", "zhou", "zhu", "zhua", "zhuai", "zhuan", "zhuang", "zhui",
            "zhun", "zhuo", "zi", "zong", "zou", "zu", "zuan", "zui", "zun", "zuo"};
    private StringBuilder buffer;
    private String resource;
    private static CharacterParser characterParser = new CharacterParser();

    public static CharacterParser getInstance() {
        return characterParser;
    }

    public String getResource() {
        return resource;
    }

    public void setResource(String resource) {
        this.resource = resource;
    }

    /** * 汉字转成ASCII码 * * @param chs * @return */
    private int getChsAscii(String chs) {
        int asc = 0;
        try {
            byte[] bytes = chs.getBytes("gb2312");
            if (bytes == null || bytes.length > 2 || bytes.length <= 0) {
                throw new RuntimeException("illegal resource string");
            }
            if (bytes.length == 1) {
                asc = bytes[0];
            }
            if (bytes.length == 2) {
                int hightByte = 256 + bytes[0];
                int lowByte = 256 + bytes[1];
                asc = (256 * hightByte + lowByte) - 256 * 256;
            }
        } catch (Exception e) {
            System.out.println("ERROR:ChineseSpelling.class-getChsAscii(String chs)" + e);
        }
        return asc;
    }

    /** * 单字解析 * * @param str * @return */
    public String convert(String str) {
        String result = null;
        int ascii = getChsAscii(str);
        if (ascii > 0 && ascii < 160) {
            result = String.valueOf((char) ascii);
        } else {
            for (int i = (pyvalue.length - 1); i >= 0; i--) {
                if (pyvalue[i] <= ascii) {
                    result = pystr[i];
                    break;
                }
            }
        }
        return result;
    }

    /** * 词组解析 * * @param chs * @return */
    public String getSelling(String chs) {
        String key, value;
        buffer = new StringBuilder();
        for (int i = 0; i < chs.length(); i++) {
            key = chs.substring(i, i + 1);
            if (key.getBytes().length >= 2) {
                value = (String) convert(key);
                if (value == null) {
                    value = "unknown";
                }
            } else {
                value = key;
            }
            buffer.append(value);
        }
        return buffer.toString();
    }

    public String getSpelling() {
        return this.getSelling(this.getResource());
    }

}

汉字编码与拼音的对应

 

package com.tan.sortadapter;

import java.util.Comparator;

import com.tan.bean.Music;

/**
 * 
 * @author tannian
 *
 */
public class PinyinComparator implements Comparator<Music> {

    @Override
    public int compare(Music o1, Music o2) {
        // TODO Auto-generated method stub
        if (o1.getSortLetters().equals("@")
                || o2.getSortLetters().equals("#")) {
            return -1;
        } else if (o1.getSortLetters().equals("#")
                || o2.getSortLetters().equals("@")) {
            return 1;
        } else {
            return o1.getSortLetters().compareTo(o2.getSortLetters());
        }
    }

}

实现Comparator接口

 

package com.tan.sortadapter;

import java.util.List;

import com.tan.bean.Music;
import com.tan.myplay.R;


import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.SectionIndexer;
import android.widget.TextView;

public class MusicAdapter extends BaseAdapter implements SectionIndexer{
    private List<Music> list = null;
    private Context mContext;
    
    public MusicAdapter(Context mContext, List<Music> list) {
        this.mContext = mContext;
        this.list = list;
    }
    
    /**
     * 当ListView数据发生变化时,调用此方法来更新ListView
     * @param list
     */
    public void updateListView(List<Music> list){
        this.list = list;
        notifyDataSetChanged();
    }

    public int getCount() {
        return this.list.size();
    }

    public Object getItem(int position) {
        return list.get(position);
    }

    public long getItemId(int position) {
        return position;
    }

    public View getView(final int position, View view, ViewGroup arg2) {
        ViewHolder viewHolder = null;
        final Music mContent = list.get(position);
        if (view == null) {
            viewHolder = new ViewHolder();
            view = LayoutInflater.from(mContext).inflate(R.layout.song_item, null);
            viewHolder.songname = (TextView) view.findViewById(R.id.song_songname);
            viewHolder.singer=(TextView) view.findViewById(R.id.song_singer);
            viewHolder.sortLetter = (TextView) view.findViewById(R.id.catalog);
            view.setTag(viewHolder);
        } else {
            viewHolder = (ViewHolder) view.getTag();
        }
        
        //根据position获取分类的首字母的Char ascii值
        int section = getSectionForPosition(position);
        
        //如果当前位置等于该分类首字母的Char的位置 ，则认为是第一次出现
        if(position == getPositionForSection(section)){
            viewHolder.sortLetter.setVisibility(View.VISIBLE);
            viewHolder.sortLetter.setText(mContent.getSortLetters());
        }else{
            viewHolder.sortLetter.setVisibility(View.GONE);
        }
    
        viewHolder.songname.setText(this.list.get(position).getSongName());
        viewHolder.singer.setText(this.list.get(position).getSinger());
        
        return view;

    }
    


    final static class ViewHolder {
        TextView sortLetter;
        TextView songname;
        TextView singer;
    }


    /**
     * 根据ListView的当前位置获取分类的首字母的Char ascii值
     */
    public int getSectionForPosition(int position) {
        return list.get(position).getSortLetters().charAt(0);
    }

    /**
     * 根据分类的首字母的Char ascii值获取其第一次出现该首字母的位置
     */
    public int getPositionForSection(int section) {
        for (int i = 0; i < getCount(); i++) {
            String sortStr = list.get(i).getSortLetters();
            char firstChar = sortStr.toUpperCase().charAt(0);
            if (firstChar == section) {
                return i;
            }
        }
        
        return -1;
    }
    
    /**
     * 提取英文的首字母，非英文字母用#代替。
     * 
     * @param str
     * @return
     */
    private String getAlpha(String str) {
        String  sortStr = str.trim().substring(0, 1).toUpperCase();
        // 正则表达式，判断首字母是否是英文字母
        if (sortStr.matches("[A-Z]")) {
            return sortStr;
        } else {
            return "#";
        }
    }

    @Override
    public Object[] getSections() {
        return null;
    }
}

用来对数据进行显示（排序）

 

package com.tan.view;

import com.tan.myplay.R;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Typeface;
import android.graphics.drawable.ColorDrawable;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.widget.TextView;

public class SideBar extends View {
    // 触摸事件
    private OnTouchingLetterChangedListener onTouchingLetterChangedListener;
    // 26个字母
    public static String[] b = { "A", "B", "C", "D", "E", "F", "G", "H", "I",
            "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V",
            "W", "X", "Y", "Z", "#" };
    private int choose = -1;// 选中
    private Paint paint = new Paint();

    private TextView mTextDialog;

    public void setTextView(TextView mTextDialog) {
        this.mTextDialog = mTextDialog;
    }


    public SideBar(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public SideBar(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public SideBar(Context context) {
        super(context);
    }

    /**
     * 重写这个方法
     */
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 获取焦点改变背景颜色.
        int height = getHeight();// 获取对应高度
        int width = getWidth(); // 获取对应宽度
        int singleHeight = height / b.length;// 获取每一个字母的高度

        for (int i = 0; i < b.length; i++) {
            paint.setColor(Color.rgb(33, 65, 98));
            // paint.setColor(Color.WHITE);
            paint.setTypeface(Typeface.DEFAULT_BOLD);
            paint.setAntiAlias(true);
            paint.setTextSize(16);
            // 选中的状态
            if (i == choose) {
                paint.setColor(Color.parseColor("#3399ff"));
                paint.setFakeBoldText(true);
            }
            // x坐标等于中间-字符串宽度的一半.
            float xPos = width / 2 - paint.measureText(b[i]) / 2;
            float yPos = singleHeight * i + singleHeight;
            canvas.drawText(b[i], xPos, yPos, paint);
            paint.reset();// 重置画笔
        }

    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        final int action = event.getAction();
        final float y = event.getY();// 点击y坐标
        final int oldChoose = choose;
        final OnTouchingLetterChangedListener listener = onTouchingLetterChangedListener;
        final int c = (int) (y / getHeight() * b.length);// 点击y坐标所占总高度的比例*b数组的长度就等于点击b中的个数.

        switch (action) {
        case MotionEvent.ACTION_UP:
            setBackgroundDrawable(new ColorDrawable(0x00000000));
            choose = -1;//
            invalidate();
            if (mTextDialog != null) {
                mTextDialog.setVisibility(View.INVISIBLE);
            }
            break;

        default:
            setBackgroundResource(R.drawable.sidebar_background);
            if (oldChoose != c) {
                if (c >= 0 && c < b.length) {
                    if (listener != null) {
                        listener.onTouchingLetterChanged(b[c]);
                    }
                    if (mTextDialog != null) {
                        mTextDialog.setText(b[c]);
                        mTextDialog.setVisibility(View.VISIBLE);
                    }
                    
                    choose = c;
                    invalidate();
                }
            }

            break;
        }
        return true;
    }

    /**
     * 向外公开的方法
     * 
     * @param onTouchingLetterChangedListener
     */
    public void setOnTouchingLetterChangedListener(
            OnTouchingLetterChangedListener onTouchingLetterChangedListener) {
        this.onTouchingLetterChangedListener = onTouchingLetterChangedListener;
    }

    /**
     * 接口
     * 
     * @author coder
     * 
     */
    public interface OnTouchingLetterChangedListener {
        public void onTouchingLetterChanged(String s);
    }

}

侧栏的实现