需求描述
最近在做蓝牙与android之间互联通信，有个需求，是通过指令，控制蓝牙开启录音，结束录音，录音过程中，将蓝牙传回的数据，转换成pcm文件，然后再做个文件列表，点击播放pcm，包括暂停，重新播放之类的操作。
蓝牙数据转pcm
蓝牙传输的数据，先转换成Byte[]，然后再转换成pcm文件，保存到本地。
我们蓝牙协议的真正数据是从字节第4位开始
public class ByteKit {
private BitOperator bitOperator;
private BCD8421Operater bcd8421Operater;
private static final ByteKit mInstance = new ByteKit();
public static ByteKit getInstance() {
return mInstance;
}
private ByteKit(){
bitOperator = new BitOperator();
bcd8421Operater = new BCD8421Operater();
}
public float parseFloatFromBytes(byte[] data, int startIndex, int length) {
return this.parseFloatFromBytes(data, startIndex, length, 0f);
}
private float parseFloatFromBytes(byte[] data, int startIndex, int length, float defaultVal) {
try {
// 字节数大于4,从起始索引开始向后处理4个字节,其余超出部分丢弃
final int len = length > 4 ? 4 : length;
byte[] tmp = new byte[len];
System.arraycopy(data, startIndex, tmp, 0, len);
return bitOperator.byte2Float(tmp);
} catch (Exception e) {
e.printStackTrace();
return defaultVal;
}
}
public String parseHexStringFormBytes(byte[] data, int startIndex, int length) {
return this.parseHexStringFormBytes(data, startIndex, length, null);
}
private String parseHexStringFormBytes(byte[] data, int startIndex, int length, String defaultValue) {
try {
byte[] tmp = new byte[length];
System.arraycopy(data, startIndex, tmp, 0, length);
return ConvertUtils.bytes2HexString(tmp);
} catch (Exception e) {
e.printStackTrace();
return defaultValue;
}
}
public String parseStringFromBytes(byte[] data, int startIndex, int lenth) {
return this.parseStringFromBytes(data, startIndex, lenth, null);
}
private String parseStringFromBytes(byte[] data, int startIndex, int lenth, String defaultVal) {
try {
byte[] tmp = new byte[lenth];
System.arraycopy(data, startIndex, tmp, 0, lenth);
return new String(tmp, "gbk");
} catch (Exception e) {
e.printStackTrace();
return defaultVal;
}
}
public String parseBcdStringFromBytes(byte[] data, int startIndex, int lenth) {
return this.parseBcdStringFromBytes(data, startIndex, lenth, null);
}
private String parseBcdStringFromBytes(byte[] data, int startIndex, int lenth, String defaultVal) {
try {
byte[] tmp = new byte[lenth];
System.arraycopy(data, startIndex, tmp, 0, lenth);
return this.bcd8421Operater.bcd2String(tmp);
} catch (Exception e) {
e.printStackTrace();
return defaultVal;
}
}
public int parseIntFromBytes(byte[] data, int startIndex, int length) {
return this.parseIntFromBytes(data, startIndex, length, 0);
}
private int parseIntFromBytes(byte[] data, int startIndex, int length, int defaultVal) {
try {
// 字节数大于4,从起始索引开始向后处理4个字节,其余超出部分丢弃
final int len = length > 4 ? 4 : length;
byte[] tmp = new byte[len];
System.arraycopy(data, startIndex, tmp, 0, len);
return bitOperator.byteToInteger(tmp);
} catch (Exception e) {
e.printStackTrace();
return defaultVal;
}
}
public Long parseLongFromBytes(byte[] data, int startIndex, int length) {
try {
// 字节数大于4,从起始索引开始向后处理4个字节,其余超出部分丢弃
final int len = length > 4 ? 4 : length;
byte[] tmp = new byte[len];
System.arraycopy(data, startIndex, tmp, 0, len);
return bitOperator.fourBytesToLong(tmp);
} catch (Exception e) {
e.printStackTrace();
return 0L;
}
}
public byte[] str2Bcd(String asc) {
int len = asc.length();
int mod = len % 2;
if (mod != 0) {
asc = "0" + asc;
len = asc.length();
}
byte abt[] = new byte[len];
if (len >= 2) {
len = len / 2;
}
byte bbt[] = new byte[len];
abt = asc.getBytes();
int j, k;
for (int p = 0; p < asc.length()/2; p++) {
if ( (abt[2 * p] >= '0') && (abt[2 * p] <= '9')) {
j = abt[2 * p] - '0';
} else if ( (abt[2 * p] >= 'a') && (abt[2 * p] <= 'z')) {
j = abt[2 * p] - 'a' + 0x0a;
} else {
j = abt[2 * p] - 'A' + 0x0a;
}
if ( (abt[2 * p + 1] >= '0') && (abt[2 * p + 1] <= '9')) {
k = abt[2 * p + 1] - '0';
} else if ( (abt[2 * p + 1] >= 'a') && (abt[2 * p + 1] <= 'z')) {
k = abt[2 * p + 1] - 'a' + 0x0a;
}else {
k = abt[2 * p + 1] - 'A' + 0x0a;
}
int a = (j << 4) + k;
byte b = (byte) a;
bbt[p] = b;
}
return bbt;
}
}
语音协议的数据是从第10位开始，数据长度是4,5两位，做如下处理
int dataLength = ByteKit.getInstance().parseIntFromBytes(data, 4, 2);
byte[] result = new byte[dataLength];
System.arraycopy(data, 10, result, 0, result.length);
ibleResponse.CONTROL_AUDIO(result);
byte[]转pcm文件
public class ByteToPcmConverter {
public static void convertByteToPcm(byte[] bytes, String filePath) throws IOException {
File file = new File(filePath);
FileOutputStream outputStream = new FileOutputStream(file,true);
outputStream.write(bytes);
outputStream.close();
}
// // 使用示例
// public static void main(String[] args) {
// byte[] bytes = {/* 这里填入你的byte数组 */};
// String pcmFilePath = "/path/to/your/pcmfile.pcm";
// String outputPath= FileUtil.getSDPath(App.getInstance(),"");
// try {
// convertByteToPcm(bytes, pcmFilePath);
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
}
在获取数据之前，比如在点击录音按钮的时候，需要生产文件，文件保存到应用私密空间，在android高版本上，需要特殊处理
outputPath= FileUtil.getSDPath(App.getInstance(),name+".pcm");
File file=new File(outputPath);
if(!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
接收数据，并转换，我这还做了个页面提示
@Override
public void CONTROL_AUDIO(byte[] bytes) {
try {
ByteToPcmConverter.convertByteToPcm(bytes, outputPath);
File file = new File(outputPath);
if (file.exists() && file.isFile()) {
long length = file.length();
double mb = (double) length / (1024 * 1024);
String format = String.format("%.4f", mb);
tv_write_progress.setText("录音成功，文件大小"+ format +"mb");
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 获取SDCard文件路径
* @param ctx
* @return
*/
public static String getSDPath(Context ctx,String fileName) {
return getSDPath(ctx,"",fileName);
}
public static String getSDPath(Context ctx,String path,String fileName) {
File sdDir = null;
boolean sdCardExist = Environment.getExternalStorageState().equals(
Environment.MEDIA_MOUNTED);// 判断sd卡是否存在
if (sdCardExist) {
if (Build.VERSION.SDK_INT >= 29) {
//Android10之后
sdDir = ctx.getExternalFilesDir(null);
// sdDir= ctx.getExternalCacheDir();
} else {
sdDir= Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
}
} else {
sdDir = Environment.getRootDirectory();// 获取跟目录
}
if(!TextUtils.isEmpty(fileName)){
if(!TextUtils.isEmpty(path))
return sdDir.toString()+path+"/"+fileName;
return sdDir.toString()+"/"+fileName;
}
if(!TextUtils.isEmpty(path))
return sdDir.toString()+path;
return sdDir.toString();
}
录音文件页面播放，暂停和文件切换播放
重点是播放pcm文件
public class PcmAudioUtils {
private AudioTrack audioTrack;
private String filePath;
private File file;
private int bufferSizeInBytes;
private Thread audioTrackThread;
private int currentPosition;
private double lastTime;
private double elapsedSeconds;//已播放时间
private double audioDurationInSeconds;//总时长
int sampleRateInHz = 8000; // 采样率
int channelConfig = AudioFormat.CHANNEL_OUT_MONO; // 声道配置
int audioFormat = AudioFormat.ENCODING_PCM_16BIT; // 音频格式
boolean pauseTag=false;
private IAudioProgress iAudioProgress;
private String playState="none";
public PcmAudioUtils(String filePath) {
file = new File(filePath);
init();
}
/**
* 初始化
*/
public void init() {
if (!file.exists()) return;
int streamType = AudioManager.STREAM_MUSIC; // 音频流类型
bufferSizeInBytes = AudioTrack.getMinBufferSize(sampleRateInHz, channelConfig, audioFormat); // 缓冲区大小
/**
* 设置音频信息属性
* 1.设置支持多媒体属性，比如audio，video
* 2.设置音频格式，比如 music
*/
AudioAttributes attributes = new AudioAttributes.Builder()
.setUsage(AudioAttributes.USAGE_MEDIA)
.setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
.build();
/**
* 设置音频格式
* 1. 设置采样率
* 2. 设置采样位数
* 3. 设置声道
*/
AudioFormat format = new AudioFormat.Builder()
.setSampleRate(sampleRateInHz)
.setEncoding(AudioFormat.ENCODING_PCM_16BIT)
.setChannelMask(channelConfig)
.build();
audioTrack = new AudioTrack(attributes,format,bufferSizeInBytes,AudioTrack.MODE_STREAM, AudioManager.AUDIO_SESSION_ID_GENERATE);
}
/**
* 停止播放录音,并释放资源
*/
public void stopPlay() {
init();
playState="stopPlay";
if (audioTrack != null) {
audioTrack.release();
}
}
/**
* 暂停
*/
public void pausePlay() {
init();
if (audioTrack != null) {
audioTrack.pause();
}
// if(audioTrackThread!=null){
// audioTrackThread.interrupt();
// }
pauseTag=true;
playState="pausePlay";
}
public void play(){
init();
long currentTimeMillis = SystemClock.elapsedRealtime();
pauseTag=false;
if(audioTrack==null){
return;
}
audioTrack.play();
playState="play";
audioTrackThread= new Thread(() -> {
FileInputStream fileInputStream = null;
lastTime=(double)currentTimeMillis / 1000;
try {
fileInputStream = new FileInputStream(file);
byte[] buffer = new byte[bufferSizeInBytes];
Log.i("PcmAudioUtils", "playAudio: "+bufferSizeInBytes);
if (currentPosition > 0) {
fileInputStream.skip(currentPosition);
}
int read = 0;
while (read != -1&&!pauseTag) {
read = fileInputStream.read(buffer);
//将缓冲区buffer写入audioTrack进行播放
int write = audioTrack.write(buffer, 0, buffer.length);
currentPosition+=write;
// if(iAudioProgress!=null){
// iAudioProgress.playProgress();
// }
elapsedSeconds+=( (double) SystemClock.elapsedRealtime() /1000-lastTime);
// Log.d("AudioTrack", "已播放时间：" +elapsedSeconds + "秒");
}
if(!pauseTag){
audioTrack.stop();
audioTrack.release();
if(iAudioProgress!=null){
iAudioProgress.setStop();
}
currentPosition=0;
}
} catch (Throwable e) {
}
});
audioTrackThread.start();
}
public void setiAudioProgress(IAudioProgress iAudioProgress) {
this.iAudioProgress = iAudioProgress;
}
public interface IAudioProgress{
void playProgress(String progress);
void setStop();
}
public void stop() {
init();
playState="none";
audioTrack.stop();
audioTrack.release();
}
public String getPlayState() {
return playState;
}
}
每次在播放或者暂停的时候，都需要调用一下init()方法，要不然回报未初始化的错误，这块正常播放应该没事，就是切换播放状态，会报错，不知道有没有其他处理办法。
剩下的就简单了，大概逻辑就是：
读取本地存储的pcm文件，在列表上展示，然后点击播放，再次点击暂停，再点击继续播放，播放完成，播放按钮变成未播放，播放途中，点击其他文件播放，正在播放的文件停止。长按文件可以删除
activity_voice_recording.xml
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#F7F7F7"
>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:gravity="center"
>
<include layout="@layout/layout_toolbar" />
<androidx.recyclerview.widget.RecyclerView
android:id="@+id/recycler_view"
android:layout_width="match_parent"
android:layout_height="0dp"
android:layout_weight="1"
android:padding="@dimen/dp_10" />
<ImageView
android:id="@+id/iv_audio"
android:layout_width="@dimen/dp_70"
android:layout_height="@dimen/dp_70"
android:layout_marginBottom="20dp"
android:src="@mipmap/icon_start_recording"/>
<TextView
android:id="@+id/tv_write_progress"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:textSize="15sp"
android:layout_marginLeft="@dimen/dp_10"
android:layout_marginRight="@dimen/dp_10"
android:textColor="@color/text_gray"
tools:text="录音已写入"
/>
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:textSize="15sp"
android:layout_margin="@dimen/dp_10"
android:textColor="@color/text_gray"
android:text="*点击列表左侧图标进行播放，长按进行删除"
/>
</LinearLayout>
<RelativeLayout
android:id="@+id/rl_recording"
android:layout_width="match_parent"
android:layout_height="match_parent">
<ImageView
android:id="@+id/iv_recording"
android:layout_width="@dimen/dp_90"
android:layout_height="@dimen/dp_90"
android:layout_marginBottom="220dp"
android:visibility="gone"
android:src="@drawable/audio_anim_image"
android:layout_centerHorizontal="true"
android:layout_alignParentBottom="true"
/>
</RelativeLayout>
</FrameLayout>
VoiceRecordingActivity.java
public class VoiceRecordingActivity extends BaseActivity {
RecyclerView recycler_view;
ImageView iv_audio;
ImageView iv_recording;
TextView tv_write_progress;
RelativeLayout rl_recording;
private List<AudioBean> dataEntityList = new ArrayList<>();
private AudioAdapter adapter;
private String folderName="BLEAUDIO";
private AnimationDrawable animationDrawable;
private String outputPath;
private String platFilePath;//播放音乐的文件地址
private PcmAudioUtils audioPlay = null;
private int selectItemPosition=-1;//已选中的列表项
@Override
public int getLayoutId() {
return R.layout.activity_voice_recording;
}
@Override
public void initViews(Bundle savedInstanceState) {
iv_audio = findViewById(R.id.iv_audio);
iv_recording = findViewById(R.id.iv_recording);
recycler_view = findViewById(R.id.recycler_view);
tv_write_progress= findViewById(R.id.tv_write_progress);
setToolBarInfo("语音录制", true);
// 初始化列表
LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this);
recycler_view.setLayoutManager(linearLayoutManager);
recycler_view.setHasFixedSize(true);
recycler_view.setItemAnimator(new DefaultItemAnimator());
recycler_view.addItemDecoration(new SpacesItemDecoration(ConvertUtils.dp2px(this, 5)));
adapter = new AudioAdapter(dataEntityList);
recycler_view.setAdapter(adapter);
adapter.setOnLongClickListener(new OnItemLongClickListener() {
@Override
public void OnLongClickListener(Object o, int position) {
AudioBean audioBean=(AudioBean)o;
new XPopup.Builder(VoiceRecordingActivity.this).asConfirm(getRsString(R.string.hint), getString(R.string.notice_delete),
new OnConfirmListener() {
@Override
public void onConfirm() {
if(audioPlay!=null){
audioPlay.stopPlay();
audioPlay=null;
}
String outputPath= FileUtil.getSDPath(App.getInstance(),audioBean.getAudioInfo());
File file=new File(outputPath);
if(file.exists()){
try {
file.delete();
getFileList();
ToastUtils.show(R.string.operate_successfully);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
}).show();
}
});
adapter.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(Object o, int position) {
AudioBean audioBean=(AudioBean)o;
String filePath=FileUtil.getSDPath(App.getInstance(),audioBean.getAudioInfo());
if(!filePath.equals(platFilePath)){
if(audioPlay!=null){
audioPlay.stop();
}
audioPlay=null;
}
platFilePath =filePath;
if(audioPlay==null){
audioPlay = new PcmAudioUtils(platFilePath);
}
if(selectItemPosition==-1){//初始阶段，没有选中播放，直接播放选中的音频
audioPlay.play();
selectItemPosition=position;
}else if(selectItemPosition==position){//如果点击的是上一次点击过的文件
if(audioPlay.getPlayState().equals("none")){//已经停止播放，重新播放
audioPlay.play();
selectItemPosition=position;
}else if(audioPlay.getPlayState().equals("play")){//已经在播放了，暂停播放
audioPlay.pausePlay();
selectItemPosition=-1;//播放停止，还原成未播放状态
}else if(audioPlay.getPlayState().equals("pausePlay")){//已经暂停播放，继续播放
audioPlay.play();
selectItemPosition=position;
}
}else{//选中的是其他列表项，把正在播放的列表项停止，变成未播放状态,播放选中列表项的文件
audioPlay.stop();
audioPlay=null;
audioPlay = new PcmAudioUtils(platFilePath);
audioPlay.play();
selectItemPosition=position;
}
dataEntityList.get(position).setAudioProgress("");
adapter.setPlayPosition(selectItemPosition);
audioPlay.setiAudioProgress(new PcmAudioUtils.IAudioProgress() {
@Override
public void playProgress(String progress) {
}
@Override
public void setStop() {
final Handler mainHandler = new Handler(Looper.getMainLooper());
// 在子线程中更新数据并刷新RecyclerView
new Thread(new Runnable() {
@Override
public void run() {
// 这里进行数据的更新操作
// updateYourData();
// 使用Handler将刷新操作切换到UI线程
mainHandler.post(new Runnable() {
@Override
public void run() {
// 在UI线程中刷新RecyclerView的适配器
selectItemPosition = -1;//播放停止，还原成未播放状态
adapter.setPlayPosition(selectItemPosition);
audioPlay=null;
}
});
}
}).start();
}
});
}
});
getFileList();
iv_audio.setTag(R.mipmap.icon_start_recording);
iv_audio.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if(!BLEUtils.isGetToken()){
ToastUtils.show(R.string.ble_break_retry);
iv_audio.setTag(R.mipmap.icon_start_recording);
iv_audio.setImageResource(R.mipmap.icon_start_recording);
stopAudio();
return;
}
Integer resourceId = (Integer) iv_audio.getTag();
if(resourceId==R.mipmap.icon_start_recording){
iv_audio.setTag(R.mipmap.icon_end_recording);
iv_audio.setImageResource(R.mipmap.icon_end_recording);
startAudio();
}else{
iv_audio.setTag(R.mipmap.icon_start_recording);
iv_audio.setImageResource(R.mipmap.icon_start_recording);
stopAudio();
}
}
});
}
private void startAudio(){
iv_recording.setVisibility(View.VISIBLE);
tv_write_progress.setVisibility(View.VISIBLE);
animationDrawable = (AnimationDrawable) iv_recording.getDrawable();
//直接就开始执行
animationDrawable.start();
String address = PreferencesUtils.getString("address");
String name= address+"--"+ DateUtils.getCurrentTime();
//保存到本地
outputPath= com.smart.bing.utils.FileUtil.getSDPath(App.getInstance(),name+".pcm");
File file=new File(outputPath);
if(!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
if(BLEUtils.isGetToken()){
LmAPI.CONTROL_AUDIO((byte) 0x1);
}
}
private void stopAudio(){
iv_recording.setVisibility(View.GONE);
tv_write_progress.setVisibility(View.GONE);
if(animationDrawable!=null){
animationDrawable.stop();
animationDrawable=null;
}
if(BLEUtils.isGetToken()){
LmAPI.CONTROL_AUDIO((byte) 0x0);
}
getFileList();
}
public void getFileList() {
dataEntityList.clear();
String outputPath=FileUtil.getSDPath(App.getInstance(),"");
File folder = new File(outputPath);
File[] files = folder.listFiles();
if (files != null) {
Arrays.sort(files, new Comparator<File>() {
@Override
public int compare(File file1, File file2) {
return Long.compare(file2.lastModified(), file1.lastModified());
}
});
for (File file : files) {
String fileName = file.getName();
String filePath = file.getAbsolutePath();
// 处理文件逻辑，比如打印文件名和文件路径
Log.d("File", "File Name: " + fileName + ", File Path: " + filePath);
String fileExtension = file.getName().substring(file.getName().lastIndexOf(".") + 1);
if("pcm".equals(fileExtension)){
AudioBean audioBean=new AudioBean();
audioBean.setAudioInfo(fileName);
audioBean.setAudioProgress("");
dataEntityList.add(audioBean);
}
}
}
adapter.notifyDataSetChanged();
}
@Override
protected void onDestroy() {
super.onDestroy();
//关闭录音
if(BLEUtils.isGetToken()){
LmAPI.CONTROL_AUDIO((byte) 0x0);
}
}
@Override
protected void onPause() {
super.onPause();
if(audioPlay!=null){
audioPlay.stopPlay();
audioPlay=null;
}
}
@Override
public void CONTROL_AUDIO(byte[] bytes) {
try {
ByteToPcmConverter.convertByteToPcm(bytes, outputPath);
File file = new File(outputPath);
if (file.exists() && file.isFile()) {
long length = file.length();
double mb = (double) length / (1024 * 1024);
String format = String.format("%.4f", mb);
tv_write_progress.setText("录音成功，文件大小"+ format +"mb");
}
} catch (IOException e) {
e.printStackTrace();
}
}
这一块有个坑，是在子线程更新adapter，直接更新会无效，需要实现子线程到主线程的转换。重点代码是：
final Handler mainHandler = new Handler(Looper.getMainLooper());
// 在子线程中更新数据并刷新RecyclerView
new Thread(new Runnable() {
@Override
public void run() {
// 这里进行数据的更新操作
// updateYourData();
// 使用Handler将刷新操作切换到UI线程
mainHandler.post(new Runnable() {
@Override
public void run() {
// 在UI线程中刷新RecyclerView的适配器
selectItemPosition = -1;//播放停止，还原成未播放状态
adapter.setPlayPosition(selectItemPosition);
audioPlay=null;
}
});
}
}).start();
AudioAdapter.java
public class AudioAdapter extends RecyclerView.Adapter<AudioAdapter.StrokeHolder> {
private OnItemClickListener onItemClickListener;
private OnItemLongClickListener onLongClickListener;
private List<AudioBean> dataEntityList = new ArrayList<>();
private int playPosition=-1;//显示播放按钮的列表项
public AudioAdapter(List<AudioBean> dataEntityList) {
this.dataEntityList = dataEntityList;
}
@Override
public StrokeHolder onCreateViewHolder(ViewGroup parent, int viewType) {
View view = View.inflate(parent.getContext(), R.layout.item_audio_layout, null);
return new StrokeHolder(view, onItemClickListener);
}
@Override
public void onBindViewHolder(StrokeHolder holder, int position) {
AudioBean resultEntity = dataEntityList.get(position);
holder.setData(resultEntity);
if(playPosition==position){
holder.ivAudioStart.setImageResource(R.mipmap.icon_end);
holder.ivAudioStart.setTag(R.mipmap.icon_end); // 存储资源 ID
}else{
holder.ivAudioStart.setImageResource(R.mipmap.icon_start);
holder.ivAudioStart.setTag(R.mipmap.icon_start); // 存储资源 ID
}
}
@Override
public int getItemCount() {
return dataEntityList.size();
}
@SuppressLint("NotifyDataSetChanged")
public void setPlayPosition(int position){
playPosition=position;
notifyDataSetChanged();
}
public AudioBean getItemBean(int position) {
return dataEntityList.get(position);
}
public void setOnItemClickListener(OnItemClickListener onItemClickListener) {
this.onItemClickListener = onItemClickListener;
}
public void setOnLongClickListener(OnItemLongClickListener onLongClickListener) {
this.onLongClickListener = onLongClickListener;
}
public void updateData(AudioBean audioBean) {
if (!dataEntityList.contains(audioBean)) {
dataEntityList.add(audioBean);
notifyDataSetChanged();
}
}
public void clearData() {
dataEntityList.clear();
notifyDataSetChanged();
}
class StrokeHolder extends RecyclerView.ViewHolder implements View.OnClickListener ,View.OnLongClickListener{
TextView tvAudioInfo;
TextView tvAudioProgress;
ImageView ivAudioStart;
OnItemClickListener onItemClick;
public StrokeHolder(View itemView, OnItemClickListener onItemClickListener) {
super(itemView);
tvAudioInfo = (TextView) itemView.findViewById(R.id.tv_audio_info);
tvAudioProgress = (TextView) itemView.findViewById(R.id.tv_audio_progress);
ivAudioStart = itemView.findViewById(R.id.iv_audio_start);
itemView.setLayoutParams(new RecyclerView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT));
this.onItemClick = onItemClickListener;
itemView.setOnClickListener(this);
itemView.setOnLongClickListener(this);
}
public void setData(AudioBean resultEntity) {
tvAudioInfo.setText(resultEntity.getAudioInfo());
tvAudioProgress.setText(resultEntity.getAudioProgress());
}
@Override
public void onClick(View v) {
if (onItemClick != null) {
onItemClick.onItemClick(dataEntityList.get(getPosition()), getPosition());
}
}
@Override
public boolean onLongClick(View v) {
if(onLongClickListener !=null){
onLongClickListener.OnLongClickListener(dataEntityList.get(getPosition()), getPosition());
}
return true;
}
}
}