Android歌词文本解析方法

1. LRC文本解读

Android中要实现滚动歌词的第一步，是需要对LRC歌词文本进行解析，首先来看一份标准的歌词文本模式：

[ti:失恋战线联盟]
[ar:草蜢]
[al:]
[00:00.00]草蜢-失恋战线联盟
[00:08.78]编辑:小婧
[01:43.33][00:16.27]她总是只留下电话号码
[01:46.97][00:19.81]从不肯让我送她回家
[01:50.61][00:23.43]听说你也曾经爱上过她
[01:54.15][00:27.07]曾经也同样无法自拔
[01:57.78][00:30.72]你说你学不会假装潇洒
[02:01.41][00:34.36]却叫我别太早放弃她
[02:05.05][00:37.99]把过去传说成一段神话
[02:08.70][00:41.59]然后笑你是一样的傻
[02:12.01][00:45.11]我们那么在乎她
[02:14.15][00:47.01]却被她全部抹杀
[02:15.96][00:48.87]越谈她越相信永远得不到回答
[02:19.57][00:52.49]到底她怎么想
[02:21.35][00:54.28]应该继续在这么
[02:23.37][00:56.36]还是说穿跑了吧
[02:26.89][00:59.80]找一个承认失恋的方法
[02:30.48][01:03.41]让心情好好地放个假
[02:34.14][01:07.00]当你我不小心又想起她
[02:45.69][02:42.20][02:37.69][01:10.60]就在记忆里画一个叉
[02:48.69]

LRC有两种类型的标签，一种是 标识标签，一种是 时间标签
- 标识标签，格式为[标识名:值]，例如[ti:失恋战线联盟]，这种预定义的标签
- 时间标签，格式为[mm:ss]或[mm:ss.ff](分钟:秒数.毫秒数)，例如[02:48.69]，其中数字必须为非负整数。
时间标签必须位于行首位置，一行歌词可以包含多个时间标签，例如[02:45.69][02:42.20][02:37.69][01:10.60]就在记忆里画一个叉，表示 “就在记忆里画一个叉” 这句在这首歌的[02:45.69][02:42.20][02:37.69][01:10.60]这四个时间节点出现过。这句歌词可以简化为

[02:45.69]就在记忆里画一个叉
[02:42.20]就在记忆里画一个叉
[02:37.69]就在记忆里画一个叉
[01:10.60]就在记忆里画一个叉

2. 从assets目录下读取LRC文件

在真实项目中一般文件需要及时去获取，此处为了方便，我们将LRC文本放在assets目录下进行读取，从assets目录下读取文件的代码如下：

/**
     * 根据文件名获取assets目录下的文件内容
     * @param fileName
     * @return
     */
private String getLrcText(String fileName) {
        String lrcText = null;
        try {
            InputStreamReader inputReader = new InputStreamReader(getResources().getAssets().open(fileName));
            BufferedReader bufReader = new BufferedReader(inputReader);
            String line = "";
            while ((line = bufReader.readLine()) != null)
                lrcText += line;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return lrcText;
    }

将text.lrc文件解析为字符串lrcText。

3. 解析由LRC文件得到的lrcText 字符串

创建LrcEntity类，用于解析每行歌词包含的内容，该类包括3个变量：time，timeLong，text。
- time： 表示当前行歌词的播放时间标签，例如[01:10.60]
- timeLong： 表示当前时间标签time转换为long型后的数值，例如[01:10.60]转换为long为70060毫秒（70060=01 * 60
1000 + 10 * 1000+60）
- text： 表示当前歌词的内容，例如就在记忆里画一个叉
创建的LrcEntity类如下所示：

/**
 * 歌词解析基类
 */
public class LrcEntity {
    public String time;
    public long timeLong;
    public String text;

    public LrcEntity(String time, String text, long timeLong) {
        this.time = time;
        this.text = text;
        this.timeLong = timeLong;
    }

    public String getTime() {
        return time;
    }

    public void setTime(String time) {
        this.time = time;
    }

    public long getTimeLong() {
        return timeLong;
    }

    public void setTimeLong(long timeLong) {
        this.timeLong = timeLong;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

    @Override
    public int compareTo(LrcEntity entity) {
        if (entity == null) {
            return -1;
        }
        return (int) (timeLong - entity.getTimeLong());
    }

    /**
     * 解析歌词文本
     * @param lrcText
     * @return
     */
    private static List<LrcEntity> parseLrc(String lrcText) {
        if (TextUtils.isEmpty(lrcText)) {
            return null;
        }

        List<LrcEntity> entityList = new ArrayList<>();
        // 将字符串以换行符切割
        String[] array = lrcText.split("\\n");
        for (String line : array) {
            // 循环遍历按行解析
            List<LrcEntity> list = parseLine(line);
            if (list != null && !list.isEmpty()) {
                entityList.addAll(list);
            }
        }

        // 使序列按大小升序排序（由小到大）
        Collections.sort(entityList);
        return entityList;
    }

    /**
     * 针对每一句歌词解析，并存到LrcEntity中
     * @param line
     * @return
     */
    private static List<LrcEntity> parseLine(String line) {
        if (TextUtils.isEmpty(line)) {
            return null;
        }
        // 去除空格
        line = line.trim();
        // 正则表达式，判断line中是否有[01:10.60]格式的片段
        Matcher lineMatcher = Pattern.compile("((\\[\\d\\d:\\d\\d\\.\\d\\d\\])+)(.+)").matcher(line);
        // 如果没有，返回null
        if (!lineMatcher.matches()) {
            return null;
        }

        // 得到时间标签
        String times = lineMatcher.group(1);
        // 得到文本内容
        String text = lineMatcher.group(3);
        List<LrcEntity> entryList = new ArrayList<>();

        Matcher timeMatcher = Pattern.compile("\\[(\\d\\d):(\\d\\d)\\.(\\d\\d)\\]").matcher(times);
        while (timeMatcher.find()) {
            long min = Long.parseLong(timeMatcher.group(1));// 分
            long sec = Long.parseLong(timeMatcher.group(2));// 秒
            long mil = Long.parseLong(timeMatcher.group(3));// 毫秒
            // 得到long型时间
            long time = min * DateUtils.MINUTE_IN_MILLIS + sec * DateUtils.SECOND_IN_MILLIS + mil * 10;
            // 最终解析得到一个list
            entryList.add(new LrcEntity(times, text, time));
        }
        return entryList;
    }
}

代码中有很详细的注释， 上述parseLine方法中用到了正则表达式，不了解的同学请自行百度，很简单。这种解析方式的弊端在于不能解析多个时间标签同时存在，当然肯定是有方法的，但是我还没学会。。。
我们来看另外一种接地气的方法：

/**
     * 针对每一句歌词解析，并存到LrcEntity中
     *
     * @param line [02:45.69][02:42.20][02:37.69][01:10.60]就在记忆里画一个叉
     * @return
     */
    public List<LrcEntity> parseLine2(String line) {
        List<LrcEntity> entryList = new ArrayList<>();
        int pos1 = line.indexOf("[");//0
        int pos2 = line.indexOf("]");//9  indexof如果找不到返回-1
        if (pos1 == 0 && pos2 != -1) {
            //long数组用于存放时间戳，判断含有多少个时间标签
            String[] times = new String[getCount(line)];
            String strTime = line.substring(pos1, pos2+1);//[02:45.69]
            // 时间标签数组
            times[0] = strTime;
            //判断是否还有下一个
            String text = line;//[02:45.69][02:42.20][02:37.69][01:10.60]就在记忆里画一个叉
            int i = 1;
            while (pos1 == 0 && pos2 != -1) {//判断是否有时间的显示，既歌词
                text = text.substring(pos2 + 1);//[02:42.20][02:37.69][01:10.60]就在记忆里画一个叉
                pos1 = text.indexOf("[");//0
                pos2 = text.indexOf("]");//9
                if (pos2 != -1) {
                    strTime = text.substring(pos1, pos2 + 1);//[02:42.20]
                    times[i] = strTime;//将第二个时间戳添加到数组中
                    if (times[i] == "") {
                        return entryList;
                    }
                }
                i++;
            }

            LrcEntity lrcEntity = new LrcEntity();
            for (int j = 0; j < times.length; j++) {
                if (times[j] != null) {
                    lrcEntity.setText(text);
                    lrcEntity.setTimeLong(Str2Long(times[j]));
                    lrcEntity.setTime(times[j]);
                    entryList.add(lrcEntity);//将歌词信息添加到集合中
                    lrcEntity = new LrcEntity();
                }
            }
        }
        return entryList;
    }

    //将字符串转换为long类型
    private long Str2Long(String strTime) {
        long showTime = -1;
        try {
            strTime = strTime.substring(1,strTime.length()-1);
            String[] s1 = strTime.split(":");
            String[] s2 = s1[1].split("\\.");
            long min = Long.parseLong(s1[0]);
            long second = Long.parseLong(s2[0]);
            long mil = Long.parseLong(s2[1]);
            showTime = min * 60 * 1000 + second * 1000 + mil * 10;
        } catch (NumberFormatException e) {
            e.printStackTrace();
        }
        return showTime;
    }

    /**
     * 判断当前行的歌词播放几次
     *
     * @param line
     * @return
     */
    private int getCount(String line) {
        String[] split = line.split("\\]");
        return split.length;
    }

由于上述代码都是重复的，这里只给出针对每一句歌词解析，并存到LrcEntity中的方法，主要是针对字符串进行切割，是字符串的基本操作，相信大家对这块都很熟悉。
最后得到了对歌词文本解析的集合，其中包括时间标签，内容以及时间标签转换为long后的数据，解析这里基本就说完了，关于歌词的显示和绘制，下次再说，谢谢大家。