一卷旌收千骑虏，万全身出百重围。这篇文章主要讲述Android为TV端助力 外挂字幕（设置颜色，大小，位置，微调字幕）相关的知识，希望能为你提供帮助。
前提摘要：
  可以给电影加字幕，目前支持srt和ass格式，
功能摘要：
  支持微调字幕，设置大小，颜色，位置
 
【Android为TV端助力 外挂字幕（设置颜色，大小，位置，微调字幕）】1 .字幕解析类

package com.hhzt.iptv.lvb_x.utils;

import android.os.Handler;
import android.util.Log;

import com.hhzt.iptv.lvb_x.Constant;
import com.hhzt.iptv.lvb_x.log.LogUtil;
import com.hhzt.iptv.lvb_x.model.Srt;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.regex.Pattern;

public class SrtUtils {
/**上一次 字幕节点*/
privatestatic int node = 0;
/**存放字幕*/
privatestaticList< Srt> srtlist = new ArrayList< Srt> ();
/**
* 正则表达式，判断是否是时间的格式
*/
private final static String equalStringExpress = "\\d\\d:\\d\\d:\\d\\d,\\d\\d\\d --> \\d\\d:\\d\\d:\\d\\d,\\d\\d\\d";
/**
* 正则表达式，判断是否是时间的格式
*/
private final static String equalExpressAss = "\\d:\\d\\d:\\d\\d.\\d\\d";

/**
* 单位转换
* 1秒=1000毫秒
*/
private final static int oneSecond = 1000;

private final static int oneMinute = 60 * oneSecond;

private final static int oneHour = 60 * oneMinute;

public static String getFileEncode(InputStream in) {
String encode;
byte[] b = new byte[3];
try {
in.read(b);
} catch (IOException e) {
e.printStackTrace();
}
if (b[0] == -17 & & b[1] == -69 & & b[2] == -65){
encode="UTF-8";
} else {
encode="GBK";
}
returnencode;
}
/**
*
* @param time 毫秒
* @return Srt
*/
public static Srt getSrt(double time) {
//System.out.println("上次节点"+node);
Log.i("TAG","getSrtgetSrt:; "+time);
int n=0;
//根据上一次节点开始查找
for (int i = node; i < srtlist.size(); i++) {
n++;
Srt str=srtlist.get(i);
//当时间小于 当前字幕段 开始时间时往回倒序查找
if(time< str.getStar()){//小于开始时间
for (int f = node -1 ; f > = 0; f--) { //倒序查找
n++;
Srt stre=srtlist.get(f);
if(stre.getStar()< =time & & time< =stre.getEnd()){
node=f; //设置节点
//符合时间段返回
// System.out.println("总查询次数 ： "+n);
return stre;
}
}
}else{
//当时间大于或等于 当前字幕段 开始时间时 顺序往下查找
if(str.getStar()< =time & & time< =str.getEnd()){
node=i; //设置节点
//符合时间段返回
//System.out.println("总循环次数 ： "+n);
return str;
}
}
}
return null;
}
/***
* 初始化字幕库
*
* @param path 本地文件路径
* @return boolean
*/
public static boolean srtInit(String path) {
boolean b=false;
File file = new File(path);
InputStream inputStream=null;
try {
inputStream = new FileInputStream(file);
String prefix=path.substring(path.lastIndexOf(".")+1);
List< Srt> list =null;
if("srt".equalsIgnoreCase(prefix)){
list = parseSrt(inputStream);
}else if("ass".equalsIgnoreCase(prefix)){
list = parseAss(inputStream);
}else{
return b;
}
srtlist=list;
node=0;
if(srtlist!=null & & srtlist.size()> 0){
b=true;
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally{
try {
if(inputStream!=null ){
inputStream.close();
}
} catch (IOException e1) {
e1.printStackTrace();
}
}
return b;
}
/***
* 初始化字幕库
* @param srturl 网络文件地址
* @return boolean
*/
public static boolean srtInitHttp(String srturl,Handler handler) {
boolean b=false;
URL url = null;
HttpURLConnection connection = null;
InputStream in = null;
try {
url = new URL(URLEncoder(srturl));
connection = (HttpURLConnection) url.openConnection();
connection.setConnectTimeout(5000);
connection.setReadTimeout(30000);
in = connection.getInputStream();
List< Srt> list =null;
String prefix=srturl.substring(srturl.lastIndexOf(".")+1);
if("srt".equalsIgnoreCase(prefix)){
list = parseSrt(in);
}else if("ass".equalsIgnoreCase(prefix)){
list = parseAss(in);
}else{
return b;
}
srtlist=list;
node=0;
if(srtlist!=null & & srtlist.size()> 0){
handler.sendEmptyMessage(Constant.IPTV_MSG_ANALYSIS_SUCCESS);
b=true;
}
} catch (Exception e) {
LogUtil.e("TAG","EEEEEEEE:"+e.getMessage());
e.printStackTrace();
} finally {
if (connection != null) {
connection.disconnect();
}
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return b;
}
/***
* 清除字幕库
* @return
*/
public static boolean srtClear() {
try {
if(srtlist!=null & & srtlist.size()> 0){
srtlist.clear();
return true;
}
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/***
* 修改字幕 当前加载的
* @param timeError需要调整的时间秒数，正数为延迟，负数为提早
*/
public static boolean update(double timeError) {
int time=(int)(timeError*1000);
for (Srt srt : srtlist) {
srt.setStar(srt.getStar()+time);
srt.setEnd(srt.getEnd()+time);
}
return false;

}
/***
* 修改字幕
* @param file 源字幕文件位置
* @param timeError需要调整的时间秒数，正数为延迟，负数为提早
* @param file新的字幕文件保存位置
*/
public static boolean update(File file,double timeError) {
boolean b=false;
long time=(long)(timeError*1000);
String path=file.getPath();
String prefix=path.substring(path.lastIndexOf(".")+1);
if("srt".equalsIgnoreCase(prefix)){
b= updateSrt(file,time);
}else if("ass".equalsIgnoreCase(prefix)){
b=updateAss(file, time);
}
return b;
}
private static boolean updateSrt(File file,long timeError){
boolean b=false;
InputStream inputStream=null;
OutputStream outputStream=null;
BufferedReader in=null;
BufferedWriter outWriter=null;

File newfile=new File(file.getParentFile().getAbsolutePath()+"/new_"+file.getName());
String line=null;
StringBuffer newLine=new StringBuffer();

try {
newfile.createNewFile(); //创建新文件
inputStream = new FileInputStream(file);
outputStream=new FileOutputStream(newfile);

in = new BufferedReader(new InputStreamReader(inputStream,getFileEncode(inputStream))); //创建文件输入流
outWriter = new BufferedWriter(new OutputStreamWriter(outputStream,getFileEncode(inputStream))); //缓冲//创建文件输出流

//以下while循环逐行读取字幕源文件
while((line=in.readLine()) != null) {
if (! Pattern.matches(equalStringExpress,line)){//进行正则式的匹配。
outWriter.write(line+"\r\n"); //println(newLine.toString()); //如果读到的不是时间描述字符行，则原样写入新文件
outWriter.flush();
continue; //提早结束本次循环继续读取下一行
}
//以下对时间描述字符行进行格式转换和数学运算
String times=line.substring(0,12);
Date date= stringToDate(times, "HH:mm:ss,SSS");
Date date2= getTimeValueSSS(date,timeError);
times=dateToString(date2, "HH:mm:ss,SSS");
/*
int times;

int second=Integer.parseInt(line.substring(6,8));
int minute=Integer.parseInt(line.substring(3,5));
int hour=Integer.parseInt(line.substring(0,2));

times=timeError+ second + minute*60 + hour*3600;
String shour= "0" + (times/3600);
String sminute="0" + ((times % 3600)/60);
String ssecond="0" + (times % 60);

int second2=Integer.parseInt(line.substring(23,25));
int minute2=Integer.parseInt(line.substring(20,22));
int hour2=Integer.parseInt(line.substring(17,19));
times=timeError+ second2 + minute2*60 + hour2*3600;

String shour2= "0" + (times/3600);
String sminute2="0" + ((times % 3600)/60);
String ssecond2="0" + (times % 60);
*/
String times2=line.substring(17,29);
date= stringToDate(times2, "HH:mm:ss,SSS");
date2= getTimeValueSSS(date,timeError);
times2=dateToString(date2, "HH:mm:ss,SSS");

newLine.setLength(0);
newLine.append(times + " --> ");
newLine.append(times2);
//最后把得到的时间描述字符行写入新文件
outWriter.write(newLine+"\r\n"); //println(newLine.toString());
outWriter.flush();
}
in.close();
outWriter.close();
String filename=file.getName();
deleteFile(file.getPath());
renameFile(newfile.getParentFile().getAbsolutePath(), newfile.getName(),filename);
b=true;
} catch (FileNotFoundException ex) {
ex.printStackTrace();
}catch (IOException ex) {
ex.printStackTrace();
}finally{
if(inputStream!=null){
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(outputStream!=null){
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(outWriter!=null){
try {
outWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(in!=null){
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return b;
}
private static boolean updateAss(File file,long timeError){
boolean b=false;
InputStream inputStream=null;
OutputStream outputStream=null;
BufferedReader in=null;
BufferedWriter outWriter=null;

File newfile=new File(file.getParentFile().getAbsolutePath()+"/new_"+file.getName());
String line=null;
StringBuffer newLine=new StringBuffer();

try {
newfile.createNewFile(); //创建新文件
inputStream = new FileInputStream(file);
outputStream=new FileOutputStream(newfile);

in = new BufferedReader(new InputStreamReader(inputStream,getFileEncode(inputStream))); //创建文件输入流
outWriter = new BufferedWriter(new OutputStreamWriter(outputStream,getFileEncode(inputStream))); //缓冲//创建文件输出流

int startIndex=-1; //事件开始的时间
int endIndex=-1; // 事件结束的时间
int textIndex=-1; //为对白字幕区域
int marginLIndex=-1; //与左边缘的距离, 为4位数字代表的像素值. 0000代表使用当前Style定义的值
int marginRIndex=-1; //与右边缘的距离, 为4位数字代表的像素值. 0000代表使用当前Style定义的值
int marginVIndex=-1; //垂直距离, 为4位数字代表的像素值. 0000代表使用当前Style定义的值
boolean events=false;
//以下while循环逐行读取字幕源文件
while((line=in.readLine()) != null) {
if ("[Events]".equals(line)){
events=true;
}
if(line!=null & & line.length()> 0 & & line.indexOf(",")> -1){
if(startIndex> -1 & & endIndex> -1){
// 填充开始时间数据
String[] contexts= line.split(",", 10);
String startime =contexts[startIndex];
// 填充开始时间数据
if(Pattern.matches("\\d:\\d\\d:\\d\\d.\\d\\d", startime)){
Date date= stringToDate(startime+"0", "H:mm:ss.SSS");
Date date2= getTimeValueSSS(date,timeError);
String strtime=dateToString(date2, "H:mm:ss.SSS");
contexts[startIndex]=strtime.substring(0, strtime.length()-1);
}
// 填充结束时间数据
String endtime =contexts[endIndex]; ;
if(Pattern.matches("\\d:\\d\\d:\\d\\d.\\d\\d", endtime)){
Date date= stringToDate(endtime+"0", "H:mm:ss.SSS");
Date date2= getTimeValueSSS(date,timeError);
String strtime=dateToString(date2, "H:mm:ss.SSS");
contexts[endIndex]=strtime.substring(0, strtime.length()-1);
}
newLine.setLength(0);
for (int i = 0; i < contexts.length; i++) {
if(i> 0){
newLine.append(",");
}
newLine.append(contexts[i]);
}
//最后把得到的时间描述字符行写入新文件
outWriter.write(newLine.toString()+"\r\n"); //println(newLine.toString());
outWriter.flush();
continue;
}else{
if(events){
if(line.startsWith("Format")){
String[] formats= line.split(",");
for (int i = 0; i < formats.length; i++) {
if("Start".equals(formats[i].trim())){
startIndex=i;
}else
if("End".equals(formats[i].trim())){
endIndex=i;
}else
if("Text".equals(formats[i].trim())){
textIndex=i;
}else
if("MarginL".equals(formats[i].trim())){
marginLIndex=i;
}else
if("MarginR".equals(formats[i].trim())){
marginRIndex=i;
}else
if("MarginV".equals(formats[i].trim())){
marginVIndex=i;
}
}
}
}
}
}
//不修改直接写入
outWriter.write(line+"\r\n");
outWriter.flush();
}
in.close();
outWriter.close();
String filename=file.getName();
deleteFile(file.getPath());
renameFile(newfile.getParentFile().getAbsolutePath(), newfile.getName(),filename);
b=true;
} catch (FileNotFoundException ex) {
ex.printStackTrace();
}catch (IOException ex) {
ex.printStackTrace();
}catch (Exception ex) {
//System.out.println(newLine);
ex.printStackTrace();
}finally{
if(inputStream!=null){
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(outputStream!=null){
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(outWriter!=null){
try {
outWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(in!=null){
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return b;
}
public static boolean renameFile(String path,String oldname,String newname){
File oldfile=new File(path+"/"+oldname);
File newfile=new File(path+"/"+newname);
if(!oldfile.exists()){
return false; //重命名文件不存在
}
if(!oldname.equals(newname)){//新的文件名和以前文件名不同时,才有必要进行重命名
if(newfile.exists())//若在该目录下已经有一个文件和新文件名相同，则不允许重命名
return false ;
else{
oldfile.renameTo(newfile);
return true;
}
}else{
return true;
}
}
public static boolean deleteFile(String fileName) {
File file = new File(fileName);
// 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
if (file.exists() & & file.isFile()) {
if (file.delete()) {
//System.out.println("删除单个文件" + fileName + "成功！");
return true;
} else {
//System.out.println("删除单个文件" + fileName + "失败！");
return false;
}
} else {
//System.out.println("删除单个文件失败：" + fileName + "不存在！");
return false;
}
}
/**
* 解析字幕
*
* @param inputStream
*字幕路径
*/
private static List< Srt> parseSrt(InputStream inputStream) {
ArrayList< Srt> list = new ArrayList< Srt> ();
BufferedReader bufferedReader = null;
try {
bufferedReader = new BufferedReader(new InputStreamReader(inputStream,getFileEncode(inputStream)));
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}
String line = null;
try {

while ((line = bufferedReader.readLine()) != null) {
Srt sm = new Srt();
// 匹配正则表达式，不符合提前结束当前行；
if (Pattern.matches(equalStringExpress, line)){
// 填充开始时间数据
sm.star = getTime(line.substring(0, 12));
// 填充结束时间数据
sm.end = getTime(line.substring(17, 29));
// 填充中文数据
sm.contextC = bufferedReader.readLine();
// 填充英文数据
sm.contextE = bufferedReader.readLine();
// 当前字幕的节点位置
sm.node = list.size() + 1;
list.add(sm);
}
}
} catch (IOException e) {
e.printStackTrace();
}
return list;
}
/**
* 解析字幕
*
* @param inputStream
*字幕路径
*/
private static List< Srt> parseAss(InputStream inputStream) {
ArrayList< Srt> list = new ArrayList< Srt> ();
BufferedReader bufferedReader = null;
try {
bufferedReader = new BufferedReader(new InputStreamReader(inputStream,getFileEncode(inputStream)));
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}
String line = null;
try {
int startIndex=-1; //事件开始的时间
int endIndex=-1; // 事件结束的时间
int textIndex=-1; //为对白字幕区域
int marginLIndex=-1; //与左边缘的距离, 为4位数字代表的像素值. 0000代表使用当前Style定义的值
int marginRIndex=-1; //与右边缘的距离, 为4位数字代表的像素值. 0000代表使用当前Style定义的值
int marginVIndex=-1; //垂直距离, 为4位数字代表的像素值. 0000代表使用当前Style定义的值
boolean events=false;

while ((line = bufferedReader.readLine()) != null) {
if ("[Events]".equals(line)){
events=true;
}
if(events){
if(line!=null & & line.length()> 0 & & line.indexOf(",")> -1){
if(line.startsWith("Format")){
String[] formats= line.split(",");
for (int i = 0; i < formats.length; i++) {
if("Start".equals(formats[i].trim())){
startIndex=i;
}else
if("End".equals(formats[i].trim())){
endIndex=i;
}else
if("Text".equals(formats[i].trim())){
textIndex=i;
}else
if("MarginL".equals(formats[i].trim())){
marginLIndex=i;
}else
if("MarginR".equals(formats[i].trim())){
marginRIndex=i;
}else
if("MarginV".equals(formats[i].trim())){
marginVIndex=i;
}
}
}else{
Srt sm = new Srt();
String[] contexts= line.split(",", 10);
if(startIndex> -1){
// 填充开始时间数据
String startime =contexts[startIndex].replace(".",",")+"0";
if(Pattern.matches("\\d:\\d\\d:\\d\\d,\\d\\d\\d", startime)){
startime="0"+startime;
}
sm.star = getTime(startime);
}
if(endIndex> -1){
// 填充结束时间数据
String endtime =contexts[endIndex].replace(".",",")+"0";
if(Pattern.matches("\\d:\\d\\d:\\d\\d,\\d\\d\\d", endtime)){
endtime="0"+endtime;
}
sm.end = getTime(endtime);
}
if(textIndex> -1){
String text=contexts[textIndex];
if(text.indexOf("\\n")> -1){

String[] strs=text.replace("\\n", "@[email  protected]").split("@[email  protected]",2);
sm.contextC =strs[0];
// 填充英文数据
sm.contextE =strs[1];
}else if (text.indexOf("\\N")> -1){

String[] strs=text.replace("\\N", "@[email  protected]").split("@[email  protected]",2);
sm.contextC =strs[0];
// 填充英文数据
sm.contextE =strs[1];
}else{
// 填充中文数据
sm.contextC =text;
}
}
// 当前字幕的节点位置
sm.node = list.size() + 1;
list.add(sm);
}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return list;
}
/**
* @param line
* @return 字幕所在的时间节点
* @descraption 将String类型的时间转换成int的时间类型
*/
private static int getTime(String line){
try
{
//0:00:05.00+0
//00:00:21,715
//System.out.println(line);
return Integer.parseInt(line.substring(0, 2)) * oneHour// 时
+ Integer.parseInt(line.substring(3, 5)) * oneMinute// 分
+ Integer.parseInt(line.substring(6, 8)) * oneSecond// 秒
+ Integer.parseInt(line.substring(9, line.length())); // 毫秒
}
catch (NumberFormatException e)
{
e.printStackTrace();
}
return -1;
}
//指定日期毫秒后的日期
private static Date getTimeValueSSS(Date d,long l){
Calendar cal=Calendar.getInstance();
cal.setTime(d);
cal.setTimeInMillis(cal.getTimeInMillis()+l);
return cal.getTime();
}
/**
* 字符串转换日期
* @param str
* @param formatprn 格式
* @return
*/
private static Date stringToDate(String str,String formatprn){
//str =" 2008-07-10 19:20:00 " 格式
SimpleDateFormat format = new SimpleDateFormat(formatprn);
if(!str.equals("")& & str!=null){
try {
return format.parse(str);
} catch (ParseException e) {
e.printStackTrace();
}
}
return null;
}
/**
* 日期转换成字符串
* @param date
* @param formatprn 格式
* @return
*/
private static String dateToString(Date date,String formatprn){
SimpleDateFormat format = new SimpleDateFormat(formatprn);
return format.format(date);
}

// 完整的判断中文汉字和符号
public static String URLEncoder(String urls) {
String[] urls2=urls.split("/");
StringBuffer srt=new StringBuffer();
for (int i = 0; i < urls2.length; i++) {
if(urls2[i]!=null & & urls2[i].length()> 0){

try {
if(isChinese(urls2[i])){
srt.append(URLEncoder.encode(urls2[i], "utf-8"));
}else{
srt.append(urls2[i]);
}
if("http:".equals(urls2[i])|| "https:".equals(urls2[i])){
srt.append("//");
}else if(i < urls2.length-1){
srt.append("/");
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
}
return srt.toString();
}
// 完整的判断中文汉字和符号
public static boolean isChinese(String strName) {
char[] ch = strName.toCharArray();
for (int i = 0; i < ch.length; i++) {
char c = ch[i];
if (isChinese(c)) {
return true;
}
}
return false;
}

// 根据Unicode编码完美的判断中文汉字和符号
private static boolean isChinese(char c) {
Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
|| ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B
|| ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS
|| ub == Character.UnicodeBlock.GENERAL_PUNCTUATION) {
return true;
}
return false;
}
}
2.字幕实体类

package com.hhzt.iptv.lvb_x.model;
/**
*
* @author Administrator
* 字幕的实体类
*/
public class Srt {
/**
* 当前节点
*/
public int node;

/**
* 开始显示的时间
*/
public int star;

/**
* 结束显示的时间
*/
public int end;

/**
* 显示的内容《英文》
*/
public String contextE;

/**
* 显示的内容《中文》
*/
public String contextC;

public int getNode() {
return node;
}

public void setNode(int node) {
this.node = node;
}

public int getStar() {
return star;
}

public void setStar(int star) {
this.star = star;
}

public int getEnd() {
return end;
}

public void setEnd(int end) {
this.end = end;
}
/**原生英文字幕*/
public String getContextE() {
return contextE;
}
/**英文字幕去除 前缀*/
public String getContextEn() {
if(contextE!=null & & contextE.length()> 0){
String regex="\\{.+?\\}";
return contextE.replaceAll(regex,"").replace("{\\fs12}", "");
}
return contextE;
}
public void setContextE(String contextE) {
this.contextE = contextE;
}
/**中文文字幕去除样式格式*/
public String getContextCn() {
if(contextC!=null & & contextC.length()> 0){
String regex="\\{.+?\\}";
return contextC.replaceAll(regex, "");
}
return contextC;
}
public String getContextC() {
return contextC;
}

public void setContextC(String contextC) {
this.contextC = contextC;
}

@Override
public String toString() {
return "Srt{" +
"node=" + node +
", star=" + star +
", end=" + end +
", contextE=‘" + contextE + ‘\‘‘ +
", contextC=‘" + contextC + ‘\‘‘ +
‘}‘;
}
}

3.activity调用

public static class NetUtil2 extends Thread {
private boolean isClose = false;
private boolean isPause = false;
/**
* 暂停线程
*/
public synchronized void onThreadPause() {
isPause = true;
}

/**
* 线程等待,不提供给外部调用
*/
private void onThreadWait() {
try {
synchronized (this) {
this.wait();
}
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 线程继续运行
*/
public synchronized void onThreadResume() {
isPause = false;
this.notify();
}

/**
* 关闭线程
*/
public synchronized void closeThread() {
try {
notify();
setClose(true);
interrupt();
} catch (Exception e) {
e.printStackTrace();
}
}

public boolean isClose() {
return isClose;
}

public void setClose(boolean isClose) {
this.isClose = isClose;
}

@Override
public void run() {
android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND);
while (!isClose & & !isInterrupted()) {
if (!isPause) {
if(!isGetReady & & null ==mMediaPlayer){
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
continue;
}

final Srt str = SrtUtils.getSrt(mMediaPlayer.getCurrentPosition()+value);
LogUtil.i("TAG","SrtSrt::"+mMediaPlayer.getCurrentPosition());
if(null == str){
try {
Thread.sleep(10);
continue;
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
LogUtil.i("TAG","getContextC11::"+str.getContextC());
LogUtil.i("TAG","tinme::"+str.getStar());
LogUtil.i("TAG","tinmeend::"+str.getEnd());

if(!str.getContextC().equalsIgnoreCase(text)){
LogUtil.i("TAG","getContextC11::"+str.getContextC());
LogUtil.i("TAG","getContextC22::"+str.getStar());
text = str.getContextCn();
text_en = str.getContextEn();
isTime = str.getEnd()-(int)value;
mMediaPlayerHandler.removeMessages(Constant.IPTV_MSG_SHOW_ANALYSIS);
mMediaPlayerHandler.sendEmptyMessage(Constant.IPTV_MSG_SHOW_ANALYSIS);
}}
} else {
onThreadWait();
}
}
}
}

 

推荐阅读

• 

  鞋类设计理论 鞋设计师
• 

  吃糖是什么意思网络用语 吃糖是什么意思
• 

  gis返回数据的格式，arcgis取反
• 

  对于目前人口老龄化这种现状,你怎么看？
• 

  吃西瓜的好处和坏处
• 

  把精力管理和时间管理结合起来2019-07-06好事
• 

  天龙八部手游科举考试有哪些题目 题目种类介绍
• 

  12306数据库泄露信息查询工具 12306数据泄露事件
• 

  大理丽江特产有哪些 丽江有哪些特产
• 

  标间是什么意思 申请标是什么意思，tm标可以申请天猫吗
• 

  最值入手的6款智能手环 什么智能手环比较好用
• 

  Win10数字小键盘怎么禁用？数字小键盘禁用详细方法介绍
• 

  济公全集电视剧完整版免费观看 济公3全集免费观看
• 

  又碰到一个奇葩的ＢＵＧ
• 

  结婚登记申请书
• 

  板栗能用烤箱烤吗
• 

  方舟生存进化2020万圣节活动有什么 2020万圣节活动一览
• 

  游戏加加会员怎么开通？游戏加加会员开通方法简述
• 

  jquery向下取证，jquery向上查找
• 

  Windows 107大版本区别在啥地方儿

• Linux/Android——input子系统核心
• Linux/Android——input_handler之evdev
• webapp检测安卓app是否安装并launch
• Linux/Android——输入子系统input_event传递
• Android 引入外部模块编译选择
• com/android/dx/command/dexer/Main : Unsupported major.minor version 52.0
• android 判断左右滑动，上下滑动的GestureDetector简单手势检测
• C .Thunder——爱阅app（测评人（方铭））
• Apple Tree POJ - 2486