miue-ui
Version:
ali miniProgram UI components for vehicle.
888 lines (863 loc) • 28.3 kB
JavaScript
/**
* author:dansion@163.com
* data:2022-07-01
* version:V1.0.0
* 2023-04-25:修订bmg可能长度为-1的情况；
*/
/*
method:
- play(idx)
- setListData(list)
Event:
- onPress(e)
- onPlaying(e)
- onEnded
*/
import INFO from '../../modules/systeminfo';
import BGM from './BGM';
import CB from './ControlButton';
//const BGM=my.getBackgroundAudioManager();
/**
* 定义当前组件事件
*
*/
const EVENT={}
// 定义事件类型
EVENT.TYPE={
PLAYING:'PLAYING',
PLAY_END:'PLAY_END',
BUTTON_PRESS:'BUTTON_PRESS',
PLAY_PAUSED:'PLAY_PAUSED',
PLAY_ERROR:'PLAY_ERROR',
BUTTON_STATE_UPDATE:'BUTTON_STATE_UPDATE',
PLAY_STATE:'PLAY_STATE',
};
let playError=(code)=>{
let errInfo="";
switch(code){
case 0:
errInfo='[0]未知错误。';
break;
case 35:
errInfo='[35]解码失败，当前资源格式不支持。';
case 1001:
errInfo="[1001]系统错误，请稍后重试。";
break;
case 10001:
errInfo="系统错误，请稍后重试。";
break;
case 10002:
errInfo="网络错误，检查网络稍后重试。";
break;
case 10003:
errInfo="资源播放失败，请稍后重试。";
break;
case 10004:
errInfo="资源格式错误，请稍后重试。";
break;
case 20000:
errInfo="播放资源为空";
break;
case 20001:
errInfo="播放失败，需要会员权限。";
break;
case 20002:
errInfo="播放失败，需要VIP会员权限。";
break;
case 20003: //表示语音
errInfo="播放失败，当前操作播放条目无效。";
break;
case 20004:
errInfo="播放失败，当前已经是列表第一个项。";
break;
case 20005:
errInfo="播放失败，当前操作已经超出列表范围。";
break;
case 20006:
errInfo="播放失败，当前资源已失效过期。";
break;
default:
errInfo=`[${code}]错误，请检查网络或多媒体流量，稍后重试。`;
break;
}
return errInfo;
}
//定义事件来源
EVENT.REFERER=[
{value:0,sign:'APP',info:'小程序自身按扭操作'},
{value:1,sign:'AUTO',info:'自动播放完成'},
{value:2,sign:'SYSTEM',info:'系统方控接收列表操作'},
{value:3,sign:'VGUI',info:'语音VGUI操作'}
];
// EVENT
EVENT.build=(target,obj)=>{
/*
* type:事件类型
* target:事件目标
* timeStamp:时间戳
* present:当前播放项索引
* referer:播放结束之后的来源信息
*
* }
*/
let _timeStamp=Date.now();
let {type,present=target.data.present,presentTrack,referer,button=null,code,message,state}=obj;
present=present?present:target.data.present;
presentTrack=presentTrack?presentTrack:target.data.list[present];
referer=referer?referer:EVENT.REFERER[0];
let _event={
type:type,
target:target.data.id,
timeStamp:_timeStamp,
present:present,
list:target.data.list,
total:target.data.total,
presentTrack:presentTrack,
referer:referer,
button:button,
code:code,
message:message,
state:state,
}
return _event;
};
//格式化时间
const formatTime=(n)=>{
n=(Number.isNaN(n))?0:n;
n=(n<0)?0:n;
n=Math.floor(n);
let h=Math.floor(n/3600) % 60;
let m=Math.floor(n/60) % 60;
// m=(m==Number.NaN)?0:m;
let s=n% 60;
//console.log(`h:${h},m:${m},s:${s}`)
return (h>0?('0'+h).slice(-2)+':':'')+(('0'+m).slice(-2)+':')+('0'+s).slice(-2);
}
Component({
mixins: [],
data: {
track:{
title:'',
singer:'',
},
slider:{
disabled:true,
value:0,
max:0,
valueString:'',
maxString:'',
},
sliderChanging:false,
buttons:[],
list:[],
total:0,
present:0,
mode:CB.STATE.MODE_NORMAL,
relation:null,// 关联列表对象
step:5,
hue:0, // 默认色相
saturation:100,
lightnessy:30, // 默认颜色的亮度
EVENT_TYPE:EVENT.TYPE,
playStartTime:0,
logo:'/logo.png',
diskmode:false,
diskmodeState:'', // diskmode状态的的图标的css 样式
},
props: {
className:'hs-player'
},
didMount() {
//初始化对象
this._init(this.props);
//重绘按扭
this._renderContinueButton();
// 初始化音频对象相关事件
BGM.onTimeUpdate((res)=>{
//console.log("BMG onTimeUpdate:"+ BGM.live);
if(!this.data.sliderChanging){ // 拖动进度条状态下，不对进度进行时间变更重绘
let _disabled=BGM.live?true:false;
this._renderSlider({value:BGM.currentTime,max:BGM.duration,disabled:_disabled,live:BGM.live})
}
});
BGM.onCanplay((res)=>{
//console.log('canplaying-------');
this.setData({playStartTime:Date.now()});
//console.log('canplaying-------'+this.data.playStartTime);
//console.log(res.data.isTrusted);
this._renderButton({type:CB.TYPE.FORWARD,disabled:false})
this._renderButton({type:CB.TYPE.BACKWARD,disabled:false})
});
BGM.onPlay(()=>{
this._renderPlayButton();
this.setData({diskmodeState:'disk_play'})
});
BGM.onPause(()=>{
this._renderPlayButton();
this.setData({diskmodeState:'disk_pause'}) // 对转盘置为停止状态；
});
BGM.onStop(()=>{
//console.log('stop-------');
this.setData({playStartTime:0});
this.setData({diskmodeState:'disk_pause'}) // 对转盘置为停止状态；
});
BGM.onEnded((res)=>{
this._continuePlay({duration:CB.TYPE.NEXT,ignoreSingle:false,referer:1});
this._renderPlayButton();
});
BGM.onError((res)=>{
res= res || {};
let {errCode,error,errorCode,data={}}=res;
let code=errCode || error || errorCode || data.errCode || data.error || data.errorCode || 0;
code= parseInt(code,10)
// 发起错误事件；
this._renderSlider({value:0,max:0,disabled:true}); // 禁用进度条
this._renderButton({type:CB.TYPE.PLAY,state:CB.STATE.PLAY,disabled:true}) // 禁用播放按扭
if(this.props.onError){ this.props.onError({type:EVENT.TYPE.PLAY_ERROR,message:playError(code)});}
});
BGM.onNext((res)=>{
this._continuePlay({duration:CB.TYPE.NEXT,ignoreSingle:true,referer:2});
this._renderPlayButton();
});
BGM.onPrev((res)=>{
this._continuePlay({duration:CB.TYPE.PREV,ignoreSingle:true,referer:2});
this._renderPlayButton();
});
// 获取系统主题变量
let {lightnessy_dark=30,lightnessy_light=70,logo=false,slogan=false,logoAnimation=''}=getApp().config || my.MIUE_CONFIG || {};
this.setData({lightnessy:lightnessy_dark});
if(logo){
this.setData({logo:logo});
this.setData({logoAnimation:logoAnimation});
}
if(slogan){
this.setData({slogan:slogan});
}
//console.warn(INFO);
INFO.read().then((res)=>{
//console.warn(res);
let _theme=res.theme || 'dark';
if(_theme=="light"){ //如果是明亮模式，则提高亮度
this.setData({lightnessy:lightnessy_light});
}
});
},
didUpdate() {
},
didUnmount() {
},
methods: {
_init(props){
//console.log(this.$page);
//向所在的Page页面注册自己
let _id=props.id?props.id:'player_'+this.$id;
if(this.$page.MIUE==undefined){
this.$page.MIUE=new Map();
}
this.$page.MIUE.set(_id,this);
this.setData({id:_id});
// 设置色相 hue
let {hue=0,saturation=100,diskmode=false}=getApp().config || my.MIUE_CONFIG || {};
this.setData({hue:hue});
//设置封面模式
this.setData({diskmode:diskmode});
// 设置饱和度
let _saturation=props.saturation || saturation ;
this.setData({saturation:_saturation});
//console.log("hue:"+ _hue);
//快进 - 快退的 步长设置
if(props.step!=undefined){
let _step=Number(props.step);
if(!Number.isNaN(_step)){
if(_step==0){
console.warn('player的step的设置有误，快进/快退 默认为 正负 5 秒。');
_step=5;
}
this.setData({step:_step})
}else{
console.warn('player的step的设置有误，快进/快退 默认为 正负 5 秒。');
}
}
//初始化播放器的按扭
let buttons_int,modes_int;
if(props.buttons==undefined){
buttons_int="prev|play|next";
}else{
buttons_int=props.buttons;
}
//播放模式的设置
if(props.modes==undefined){
modes_int="normal|loop|single|random";
}else{
modes_int=props.modes;
}
//按扭设转化成数组
let buttonsArray=buttons_int.split('|');
//模式按扭可用状态转化成组数
let modes=modes_int.split('|');
this._initButtons({menus:buttonsArray,modes:modes});
},
_initButtons(obj){ //初始化控制按扭
let {menus,modes,progress=false}=obj;
let _buttons=[];
menus.forEach((ele,idx)=>{
let disabled=this._verifyButtonDisabled(ele); // 当前按扭初始是不是可用状态
let states=null;
if(ele=='mode'){ // 模式按扭，入参 states，当前只是可以配置 模式按扭是状态列表可配置。
states=modes;
}
let _cb=CB.create({type:ele,states:states,disabled:disabled});
if(_cb){_buttons.push(_cb)}
});
this.setData({buttons:_buttons});
},
_verifyButtonDisabled(type){ //初始化 按扭的是否可用状态
// 变为小写，移除 + 号护展功能设置
type=type.replace(/\W+/ig,"")
type=type.toLowerCase();
switch(type){
case CB.TYPE.PLAY:
return (BGM.src==undefined)?true:false;
break;
case CB.TYPE.RATE:
return (BGM.playbackRate==undefined)?true:false;
break;
case CB.TYPE.LIST:
//return true;
//return (this.data.list.length<1)?true:false;
break;
case CB.TYPE.NEXT:
return (this.data.list.length<1)?true:false;
break;
case CB.TYPE.PREV:
return (this.data.list.length<1)?true:false;
break;
case CB.TYPE.FORWARD:
return (BGM.src=='')?true:false;
break;
case CB.TYPE.BACKWARD:
return (BGM.src=='')?true:false;
break;
default:
return false;
break;
}
},
_renderPlayButton(){ //更新播放状态按扭和BGM对象的状态同步。
let state='play';
if(BGM.paused){
this._renderButton({type:CB.TYPE.PLAY,state:CB.STATE.PLAY,disabled:false})
state='paused';
}else{
this._renderButton({type:CB.TYPE.PLAY,state:CB.STATE.PAUSE,disabled:false})
}
this.distributeEvent({type:EVENT.TYPE.PLAY_STATE,state:state});
},
//更新进度条状态
_renderSlider(sliderObj){ // 更新进度条件情况
// value:BGM.currentTime,max:BGM.duration,disabled:_disabled,live:BGM.live
let _slider=this.data.slider;
let {value,max,disabled=false,live}=sliderObj;
value=Number(value);
max=Number(max);
//当前值不是数据或总长度不是数值，进度条不可用。
if(Number.isNaN(value) || Number.isNaN(max)){
disabled=true;
}
_slider.disabled=disabled;
//处理百份比,当前值是数字的情况才对进度条进行设置
if(!Number.isNaN(value) && !Number.isNaN(max)){
value=Math.floor(value);
max=Math.floor(max)+0.001; // 不能 0，所以加个数字；在一定情况下 0 对setData不生效，且百分比计算可能出错；
_slider.value=value;
_slider.max=max;
_slider.valueString=formatTime(value);
_slider.maxString=formatTime(max);
//if(max>=value){
_slider.percent=Math.ceil(value/max * 100);// 百分比应用 ceil 向上取整；
//}
}else{
_slider.percent=0;
}
//console.log(`_slider.percent:${_slider.percent},value:${value},max:${max}`)
//处理直播的多媒体
if(live){
_slider.maxString="直播";
/*if(value>0){ //当前时间有效时；
_slider.valueString=formatTime(value);
}else */
if(this.data.playStartTime>0){
_slider.valueString=formatTime((Date.now()-this.data.playStartTime)/1000);
}
_slider.value=0;
_slider.max=100;
_slider.percent=0;
}
//console.log(!this.data.sliderChanging);
//console.log(_slider.percent);
// 当不在拖动状态时才对进行条的进度进行setData操作
if(!this.data.sliderChanging){
//console.log(`对进度条进行复值：${_slider.value}`)
this.setData({sliderValue:_slider.value})
}
this.setData({slider:_slider});
},
_renderButton(buttonObj,direction){ //更新按扭状态
//argObj:type,state,disabled
let {type,state,disabled=false}=buttonObj;
let _buttons=this.data.buttons;
_buttons.some((value, index, array)=>{
if(type==value.type){
//根据 direction 对顺序进行切换
if(direction!=undefined){
value.current=(value.current+direction) % value.states.length;
state=value.states[value.current].key;
}
if(state!=undefined){
value.state=state;
}
value.disabled=disabled;
return true;
}
});
this.setData({buttons:_buttons});
return {type:type,state:state,disabled:disabled};
},
_continuePlay(obj){
/* 继续播放控制函数
duration入参为TYPE.NEXT,或 TYPE.PREV
referer入参：0=小程序按扭，1= 列表播放完成，2 = 系统方控，4= VGUI语音
ignoreSingle：是否忽略单曲控制，true:强制跳过单曲。
*/
let {duration,referer=0,ignoreSingle=false}=obj;
let {mode,present,list}= this.data;
let _length=list.length;
let _prevPresent=present;
// 忽略单曲模式下，将模式切为顺序模式。
if(ignoreSingle && mode==CB.STATE.MODE_SINGLE) {
mode=CB.STATE.MODE_NORMAL;
}
//console.log("mode:"+mode);
let isStop=false;
switch(mode){
//顺序播放
case CB.STATE.MODE_NORMAL:
if(duration==CB.TYPE.NEXT){
present++;
present=(present==_length)?_length-1:present;
}
if(duration==CB.TYPE.PREV){
present--;
present=(present<0)?0:present;
}
break;
//循环播放
case CB.STATE.MODE_LOOP:
if(duration==CB.TYPE.NEXT){
present++;
present=(present==_length)?0:present;
}
if(duration==CB.TYPE.PREV){
present--;
present=(present<0)?_length-1:present;
}
break;
//倒序
case CB.STATE.MODE_FORWARD:
if(duration==CB.TYPE.NEXT){
present--;
present=(present<0)?0:present;
}
if(duration==CB.TYPE.PREV){
present++;
present=(present==_length)?present-1:present;
}
break;
//随机
case CB.STATE.MODE_RANDOM:
_prevPresent=null;
present=Math.floor(_length*Math.random());
break;
//单曲播
case CB.STATE.MODE_SINGLE:
_prevPresent=null;
break;
default:
return false;
break;
}
// 变更的情况/设置列表，播控有效的情况
//console.warn(`present:${present},_prevPresent:${_prevPresent}`)
if(present!=_prevPresent){
this.setData({present:present});
// console.warn(`present=_prevPresent,and this.play(present),present=${present}}`)
this.play(present);
}else{
//todo: 表示播放列表已经结束了
//播控无效了，表示已经结束播放。
if(present==_length-1){
this.distributeEvent({
type:EVENT.TYPE.PLAY_END,
present:present,
referer:EVENT.REFERER[referer]
});
}else if(present==0){ //
this.distributeEvent({type:EVENT.TYPE.PLAY_ERROR,code:20004,message:playError(20004)});
}
}
//console.log("present end:"+present);
},
_playSeekPosition(time){
let {currentTime,duration}=BGM;
currentTime=currentTime+time;
if(currentTime>duration){
currentTime=duration;
}
if(currentTime<0){
currentTime=0;
}
BGM.seek(currentTime);
},
//重绘更新 上一首/下一首按扭
_renderContinueButton(type){
let {mode,present}=this.data;
let isStop=false;
let max=this.data.list.length-1;
max=max<0?0:max;
let _prev={type:CB.TYPE.PREV,disabled:false};
let _next={type:CB.TYPE.NEXT,disabled:false};
let _list={type:CB.TYPE.LIST,disabled:false};
if((mode==CB.STATE.MODE_NORMAL && present==0)||(mode==CB.STATE.MODE_SINGLE && present==0)||(mode==CB.STATE.MODE_FORWARD && present==max)){
_prev={type:CB.TYPE.PREV,disabled:true};
isStop=true;
}
if((mode==CB.STATE.MODE_NORMAL && present==max)||(mode==CB.STATE.MODE_SINGLE && present==max)||(mode==CB.STATE.MODE_FORWARD && present==0)){
_next={type:CB.TYPE.NEXT,disabled:true};
isStop=true;
}
//如果列表为空，上/下 按扭都不可用。
if(max==0){
_prev={type:CB.TYPE.PREV,disabled:true};
_next={type:CB.TYPE.NEXT,disabled:true};
_list={type:CB.TYPE.LIST,disabled:true};
}
this._renderButton(_prev);
this._renderButton(_next);
this._renderButton(_list);
return isStop;
},
play(idx){
// idx= 列表索引值，或直obj.index,
// console.log(`play(idx):idx=${idx}`);
let _present;
let _list=this.data.list;
if(typeof(idx)=="number"){
_present=idx;
}
if(typeof(idx)=="object"){
_present=idx.index;
}
// 当前播放项目
let _presentTrack=_list[_present];
// 当播放项目不为空的情况进行
if(_presentTrack==undefined){
//console.warn(_present);
if(_present<0){
this.distributeEvent({type:EVENT.TYPE.PLAY_ERROR,code:20004,message:playError(20004)});
}else if (_present>=_list.length){
this.distributeEvent({type:EVENT.TYPE.PLAY_ERROR,code:20005,message:playError(20005)});
}else{
this.distributeEvent({type:EVENT.TYPE.PLAY_ERROR,code:20003,message:playError(20003)});
}
//throw('Play.play(idx) 无法播放，播放列表数据为空');
//return true;
}else{
//设置当前是列表几第个～～
this.setData({present:_present});
//圆形进度条重为0；
this.setData({percent:0});
//更新界面内容
let track=this.data.track;
track.title=_presentTrack.title;
track.singer=_presentTrack.singer;
track.pic=_presentTrack.picture;
track.comment=_presentTrack.comment;
this.setData({track:track});
//渲染下一首/下一首是否可用
this._renderContinueButton();
//开始播放
let _src;
if(typeof(_presentTrack)=="string"){
_src=_presentTrack;
}else{
_src=_presentTrack.src;
}
//当资源不为空的情况下，抛出正常的播放事件；
if(_src!=""){
let {expires=0}=_presentTrack;
let _now=Date.now();
//console.log(`expires:${expires},now:${_now}`)
if(expires>0 && expires<_now){
//console.log(`过期了～～`)
this.distributeEvent({type:EVENT.TYPE.PLAY_ERROR,code:20006,message:playError(20006)});
}else{
BGM.src=_presentTrack;
this.distributeEvent({
type:EVENT.TYPE.PLAYING,
present:_present,
presentTrack:_presentTrack,
});
}
}else{
BGM.src='';
this._renderSlider({value:0,max:0,disabled:true}); // 禁用进度条
this._renderButton({type:CB.TYPE.PLAY,state:CB.STATE.PLAY,disabled:true}) // 禁用播放按扭
// 当资源为空的情况的细分处理，vip为VIP可用资源，member表示会员可用资源；
if(_presentTrack.flag=='vip'){
this.distributeEvent({type:EVENT.TYPE.PLAY_ERROR,code:20002,message:playError(20002)});
}else if(_presentTrack.flag=='member'){
this.distributeEvent({type:EVENT.TYPE.PLAY_ERROR,code:20001,message:playError(20001)});
}else{
this.distributeEvent({type:EVENT.TYPE.PLAY_ERROR,code:20000,message:playError(20000)});
}
}
// 这里可以配直关联列表
if(this.data.relation!=null){
this.data.relation.setPresent(_present);
}
}
},
setRelation(obj){
this.data.relation=obj;
obj.data.relation=this;
},
setListData(ls){
this.setData({total:0});
this.setData({list:ls});
this.setData({total:ls.length});
//列表重新赋值之后，需要重新计上一首/下一首/按扭可用性。
this._renderContinueButton();
},
setTotal(n){
this.setData({total:n});
},
onSliderChange(e){
BGM.seek(e.detail.value);
this._renderSlider({value:e.detail.value,max:e.target.dataset.max,disabled:false});
this.setData({sliderChanging:false});
},
onSliderChanging(e){
//console.log(e);
this.setData({sliderChanging:true});
this._renderSlider({value:e.detail.value,max:e.target.dataset.max,disabled:false});
},
onButtonTap(e){
//console.log(e);
let direction=undefined;
if(e.type=='tap'){
direction=1;
}
let {type,state,disabled=false}=e.target.dataset;
// 如果 disabled= undefined 定义为 false
let _event={type:type,state:state,disabled:disabled};
switch(type){
// 播放按扭被点击
case CB.TYPE.PLAY:
if(state==CB.STATE.PAUSE){
BGM.pause();
_event.state=CB.STATE.PAUSE;
}else if(state==CB.STATE.PLAY){
BGM.play();
_event.state=CB.STATE.PLAY;
}
break;
case CB.TYPE.NEXT: // 下一首，忽略单曲模式
this._continuePlay({duration:type,ignoreSingle:true});
break;
case CB.TYPE.PREV: // 上一首，忽略单曲模式
this._continuePlay({duration:type,ignoreSingle:true});
break;
case CB.TYPE.FORWARD: //快进
this._playSeekPosition(this.data.step);
break;
case CB.TYPE.BACKWARD: //快退
this._playSeekPosition(-this.data.step);
break;
case CB.TYPE.LIST: // 列表被点击
_event=this._renderButton({type:type,state:state,disabled:false});
//_event=this._renderButton({type:type,state:state,disabled:false},direction);
break;
case CB.TYPE.FAVORITE: // 收藏按扭被击
break;
case CB.TYPE.RATE:
_event=this._renderButton({type:type,state:state,disabled:false},direction);
break;
case CB.TYPE.MODE:
_event=this._renderButton({type:type,state:state,disabled:false},direction);
//变更模式
this.setData({mode:_event.state});
//模式变化之后重绘 上一首/下一首 的状态。
this._renderContinueButton(CB.TYPE.MODE);
break;
default:
break;
}
this.distributeEvent({
type:EVENT.TYPE.BUTTON_PRESS,
button:_event,
});
},
distributeEvent(obj){
let _event=EVENT.build(this,obj);
let {type}=obj;
//console.log(_event);
switch(type){
// 按扭按下
case EVENT.TYPE.BUTTON_PRESS:
if(this.props.onPress){this.props.onPress(_event);}
break;
//当前播放
case EVENT.TYPE.PLAYING:
if(this.props.onPlaying){this.props.onPlaying(_event);}
break;
//播放结束
case EVENT.TYPE.PLAY_END:
if(this.props.onEnded){ this.props.onEnded(_event);}
break;
case EVENT.TYPE.PLAY_STATE:
if(this.props.onState){this.props.onState(_event);}
break;
//播放错误
case EVENT.TYPE.PLAY_ERROR:
this.setData({diskmodeState:'disk_pause'}) // 对转盘置为停止状态；
if(this.props.onError){ this.props.onError(_event);}
break;
default:
return false;
break;
}
},
get EVENT_TYPE(){
return EVENT.TYPE;
},
get BUTTON_TYPE(){
return CB.TYPE;
},
get BUTTON_STATES(){
return CB.STATE;
},
//end distributeEvent
//VGUI-语音命令处理函数
onVoiceCommand(e){
// 获取语音VGUI的热词
/*
let {result=0,command={}}=e || {};
let {action}=command || {}; // action: next,previous,select
switch(action){
case 'select':
this.play(result);
break;
case 'next':
this._continuePlay({duration:CB.TYPE.NEXT,ignoreSingle:true,referer:4});
this._renderPlayButton();
break;
case 'previous':
this._continuePlay({duration:CB.TYPE.PREV,ignoreSingle:true,referer:4});
this._renderPlayButton();
break;
default:
return false;
break;
}
*/
},
onVoiceAction(e){
let {querywords=''}=e; //获取Voice 的关健词
let {buttons}=this.data;
buttons.forEach((ele,idx)=>{
let matchButton=ele.hasVoice(querywords);
let {match=false,state,disabled}=matchButton || {};
if(match){ //是否命中语音注的词;
let tapEvent={
type:'voice',
timeStamp:Date.now(),
target:{dataset:{
type:ele.type,
state:state,
disabled:disabled
}
}
}
this.onButtonTap(tapEvent);
}
})
},
setHue(s){
this.setData({hue:s});
},
// 设置播放模式；
setMode(modeState){
// 模式不支持的情况；
if(!CB.verify(CB.TYPE.MODE,modeState)){
console.warn('Player.SetMode() 设置失败，入参非法');
return false;
}
// 当前设置中是不是含这个；
let mode=new Map();
let {buttons}=this.data;
// console.log(buttons);
buttons.forEach((ele,idx)=>{
if(ele.type==CB.TYPE.MODE){
mode=ele;
}
})
if(!mode.statesMap.has(modeState)){
console.warn(`Player.SetMode() 设置失败，原 mode 中不含${modeState}`)
return false;
}
if(mode.state==modeState){
console.warn(`Player.SetMode() 设置失败，原 mode 已是 ${modeState}`)
return false;
}
// console.warn(`Player.SetMode() 设置为：${modeState}`)
let tapEvent={
type:'auto',
timeStamp:Date.now(),
target:{dataset:{
type:CB.TYPE.MODE,
state:modeState,
disabled:false
}
}
}
if(this.props.onUpdate){
this.props.onUpdate(
{
type:EVENT.TYPE.BUTTON_STATE_UPDATE,
buttonType:CB.TYPE.MODE,
original:CB.BUTTONS.get(CB.TYPE.MODE).legalStates.get(mode.state),
current:CB.BUTTONS.get(CB.TYPE.MODE).legalStates.get(modeState)
}
);}
this.onButtonTap(tapEvent);
// console.log(tapEvent);
},
onPlayerTap(e){
//console.log(e);
if(this.props.onTap){ this.props.onTap(e);}
},
onTest(e){
//this.onVoiceAction({querywords:'关闭列表'});
/*
let event={
result:99,
command:{
action:'select'
}
}
this.onVoiceCommand(event);
*/
}
//
},
});