自己用shell写了个播放列表管理并支持mplayer播放

MacLinuXp

1. #!/bin/bash
   
2. : <<StoreFormat
   
3. 用':'将所有播放列表分开 用'|'将播放列表名和歌曲分开 用':'分开的第一项标示当前正在播放的列表和该列表当前正在播放的歌曲
   
4. 比如”2|1:aaa|a.mp3 b.mp3 c.mp3:bbb|b.mp3 m.mp3:ccc|c.mp3 d.mp3“表示有3个播放列表，而bbb播放列表的b.mp3正在播放
   
5. StoreFormat
   
6. 
   
7. #createCommandList
   
8. #===================================================
   
9. #定义3个数组，
   
10. #listNameArray：表示所有播放列表的名字
    
11. #listSizeArray：表示每个播放列表包含歌曲数目
    
12. #allSongs：表示所有歌曲。并且是按照播放列表0-N排列。DataSource
    
13. 
    
14. 
    
15. ######################全局变量定义##################
    
16. OPERATEPLAYLISTSOVER="false"
    
17. EXITSTATE="false"
    
18. EXITAPLAYLIST="false"
    
19. DATAFILE="data.txt"
    
20. ##################################################
    
21. #================================
    
22. #检查是否安装了mplayer
    
23. #########################
    
24. checkEnv(){
    
25.         which mplayer &>/dev/null
    
26.         if [ $? -ne 0 ]
    
27.         then
    
28.                 echo "没有安装mplayer，请先安装mplayer"
    
29.                 exit 1
    
30.         fi
    
31. }
    
32. #参数 $1:数据源文件,包含所有播放列表和歌曲的文件
    
33. initDataSourceFromFile(){
    
34.         if [ ! -e $1 ]
    
35.         then
    
36.                 touch $1
    
37.                 echo "0|0">>$1
    
38.         fi
    
39.         local OLDIFS=$IFS
    
40.         IFS=":"
    
41.         local index=0
    
42.         local k=0;
    
43.         local i;
    
44.         local flarr;
    
45.         for i in $(<$1)
    
46.         do
    
47.                        
    
48.                 listNameArray[$index]=$(echo $i | cut -d'|' -f1)
    
49.                 fileLists=$(echo $i | cut -d'|' -f2)
    
50.                 OLDIFS_2=IFS
    
51.                 IFS=" "
    
52.                 flarr=($fileLists)        #转化为数组 或者 (${fileLists[@]})
    
53.                 allSongs=(${allSongs[@]} ${fileLists[@]})
    
54.                 listSizeArray[$index]=${#flarr[@]}
    
55.                 IFS=$OLDIFS_2
    
56.                 let "index++"
    
57.         done
    
58.         IFS=$OLDIFS
    
59. }
    
60. 
    
61. 
    
62. ####################################################
    
63. #参数说明： $1表示要写入的文件名字
    
64. writeToFile(){
    
65.         echo "" > $1
    
66.         local allStr=""
    
67.         local plName   
    
68.         local song
    
69.         local i=0
    
70.         local size=0
    
71.         local iterator=0;
    
72.         for plName in "${listNameArray[@]}"   #####这里加上引号是因为如果array里面包含一项有空格，那么这里输出会出错，比如“new playlist"这种相会变成两项
    
73.         do
    
74.                 allStr="$allStr$plName|"
    
75.                 size=${listSizeArray[$i]}
    
76.                 let "size+=0"
    
77.                 local count=0;
    
78.                 while [ "$count" -ne "$size" ]
    
79.                 do
    
80.                         allStr="$allStr${allSongs[$iterator]} "
    
81.                         let "iterator++"
    
82.                         let "count++"
    
83.                 done
    
84.                 let "i++"
    
85.         allStr="$allStr:"
    
86.         done
    
87.         echo "$allStr" > $1
    
88. }
    
89. ###########################################################################
    
90. #播放列表操作
    
91. #判读播放列表序号是否越界
    
92. #参数：$1表示播放列表序号
    
93. #返回:1表示错误，0表示正确
    
94. private_isPlayListIndexOverFlow(){
    
95.         local isOverFlow=0
    
96.         local playListIndex=$1
    
97.         let "playListIndex+=0"
    
98.         if [ $? -ne 0 ] || [ $playListIndex -lt 1 ] || [ $playListIndex -gt $((${#listNameArray[@]}-1)) ]
    
99.         then
    
100.                 #echo "needPlayListIndex == $needPlayListIndex"
     
101.                 #echo "${#listNameArray[@]}"
     
102.                 echo "播放列表Index 错误,index 应该 1 到 $((${#listNameArray[@]}-1))"
     
103.                 return 1
     
104.         fi
     
105.         return 0;
     
106. }
     
107. #新建播放列表
     
108. #参数 $1 表示播放列表名字 判断播放列表是否存在
     
109. private_isPlayListExist(){
     
110. #        echo $1 =================**************${#listNameArray[@]} ******
     
111.         local ii
     
112.         for ii in ${listNameArray[@]}
     
113.         do
     
114.                 if [ "$1" == "$ii" ]
     
115.                 then
     
116.                         return 1
     
117.                 fi
     
118.         done
     
119.         return 0
     
120. }
     
121. #====================================
     
122. #参数介绍$1表示需要添加的播放列表index
     
123. #向播放列表添加歌曲
     
124. 
     
125. addASongToPlayList(){
     
126.         showAllPlayLists
     
127.         echo "请输入单个歌曲和包含mp3的目录(使用绝对路径): 使用路径时，可以指定搜索深度 如果不指定搜索深度将按照递归查找该目录下的mp3文件"
     
128.         echo "单个文件用法:xxx.mp3"
     
129.         echo "目录用法: Dir 或者 Dir:1"
     
130.         local arg
     
131.         read arg
     
132.         echo "arg ===================$arg"
     
133.         local OLDIFS=$IFS
     
134.         IFS=":"
     
135.         local arr=($arg)
     
136.         local arglen=${#arr[@]}
     
137.         let "arglen+=0"
     
138.         if [ "$arglen" -gt 2 ] || [ "$arglen" -lt 1 ]
     
139.         then
     
140.                 echo 参数个数错误
     
141.                 IFS=$OLDIFS
     
142.                 return
     
143.         else
     
144.                 local playlistIndex=$1
     
145.                 let "playlistIndex+=0"
     
146.                 if [ $? -ne 0 ] || [ $playlistIndex -eq 0 ]
     
147.                 then
     
148.                         IFS=$OLDIFS
     
149.                         echo "index 错误,index 应该 1 到 $((${#listNameArray[@]}-1))"
     
150.                         return
     
151.                 fi
     
152.                 local playlistStr=""
     
153.                 local dirOrFile=${arr[0]}
     
154.                 local findResult
     
155.                 if [ ! -e "$dirOrFile" ]
     
156.                 then
     
157.                         echo "${arr[@]}"
     
158.                         IFS=$OLDIFS
     
159.                         echo "$dirOrFile 文件或目录不存在"
     
160.                         return
     
161.                 fi
     
162.                 if [ $arglen -eq 1 ]
     
163.                 then       
     
164.                         if [ -d "$dirOrFile" ]
     
165.                         then
     
166.                                 local OLDIFSINIF=$IFS
     
167.                                 IFS=\n'
     
168.                                 local findResult=($(find $dirOrFile -name "*.mp3" -type f))
     
169.                                 echo "找到 ${#findResult[@]} 首歌曲"
     
170.                        
     
171.                                 IFS=$OLDIFSINIF
     
172.                         else
     
173.                                 echo "参数是单个文件  is $dirOrFile"
     
174.                                 if [ ${#dirOrFile} -gt 4 ] || [ "${$dirOrFile:-4}" != ".mp3" ]
     
175.                                 then
     
176.                                         echo "必须mp3文件"
     
177.                                         IFS=$OLDIFS
     
178.                                         return
     
179.                                 fi
     
180.                                 findResult[0]="$dirOrFile"
     
181.                         fi
     
182.                
     
183.                 elif [ "$arglen" -eq 2 ]
     
184.                 then
     
185.                         echo "参数个数是3"
     
186.                
     
187.                         if [ ! -d "$dirOrFile" ]
     
188.                         then
     
189.                                 echo "当参数有3个的时候，第二个参数必须是目录"
     
190.                                 IFS=$OLDIFS
     
191.                                 return
     
192.                         fi
     
193.                         local depth=${arr[1]}
     
194.                         let "depth+=0" 2>/dev/null
     
195.                         if [ $? -ne 0 ]
     
196.                         then
     
197.                                 echo "当有3个参数时,第3个参数必须是整数"
     
198.                                 IFS=$OLDIFS
     
199.                                 return
     
200.                         fi
     
201.                         local OLDIFSINSECONDIF=$IFS
     
202.                         IFS=\n'
     
203.                         local findResult=($(find $dirOrFile -maxdepth $depth -name "*.mp3" -type f))
     
204.         #                echo "------------------------------------------------找到 ${#findResult[@]} 首歌曲"
     
205.                        
     
206.                         IFS=$OLDIFSINSECONDIF
     
207.                
     
208.                 else
     
209.                         echo "参数错误"
     
210.                         IFS=$OLDIFS
     
211.                         return
     
212.                 fi
     
213.                 #echo "-----------------------------findResult  count = ${#findResult[@]}"
     
214.                 local OLDIFSSave=$IFS
     
215.                 IFS=\n'
     
216.                 if [ "${#findResult[@]}" -eq 0 ]
     
217.                 then
     
218.                         echo "没找到任何歌曲"
     
219.                         IFS=$OLDIFS #IFS使用要谨慎，记得要恢复。特别是分支多了，容易漏掉
     
220.                         return
     
221.                 fi
     
222.                 local file
     
223.                 echo "是否将所有包含空格的文件名中的空格替换为'_'(注意该项如果选择yes，会真正改变硬盘中文件的名字,选择no只会将不包含空格的mp3文件选择出来):[yes/no]?"
     
224.                 read replace
     
225.                 if [ "$replace" != "yes" ]
     
226.                 then
     
227.                         echo "暂不支持包含空格的文件名字,所以不会将包含空格的文件添加进播放列表"       
     
228.                 fi
     
229.                 local sublen=0
     
230.                 local arr;
     
231.                 echo "------------------------------------------------找到 ${#findResult[@]} 首歌曲"
     
232.                 for file in ${findResult[@]}
     
233.                 do       
     
234.                         local OLDIFS_4;
     
235.                         OLDIFS_4=$IFS
     
236.                         IFS=" "
     
237.                         arr=($file)
     
238.                         sublen=${#arr[@]}
     
239.                         let "sublen+=0"
     
240.                         IFS=$OLDIFS_4
     
241.                         local newName
     
242.                         newName=$file
     
243.                         if [ $sublen -ne 1 ] #如果长度不是1 ，表示里面有空格：
     
244.                         then
     
245.                        
     
246.                                 if [ "$replace" == "yes" ]
     
247.                                 then
     
248.                                         newName=${file// /_}
     
249.                                         $(mv "$file" "$newName")
     
250.                                 else
     
251.                                         continue
     
252.                                        
     
253.                                 fi
     
254.                
     
255.                 ${listSizeArray[$needPlayListIndex]}        else       
     
256.                                 echo "没有空格"
     
257.                         fi
     
258.                
     
259.                         playlistStr="$playlistStr$newName "
     
260.                 done
     
261.                 #echo "playlistStr ==========================$playlistStr"
     
262.                 IFS=$OLDIFSSave
     
263.                 local OLDIFS_1=$IFS
     
264.                 IFS=" "
     
265. #                echo "playindex ========= $playlistIndex==========arrsize ==================${listSizeArray[@]}"
     
266.                 local insertIndex=0
     
267.                 local step=0
     
268.                 while [ "$step" -le "$playlistIndex" ]
     
269.                 do
     
270. #                        echo "step =============$step"
     
271.                         let "insertIndex+=${listSizeArray[$step]}"
     
272.                         let "step++"
     
273.                 done
     
274. #####################################################################
     
275. # 将歌曲插入列表
     
276.         #        echo  "the position is $insertIndex"  //取得应该插入的index
     
277. #                echo "allSongs ==========${#allSongs[@]}"
     
278.                 local afterIndexArr=${allSongs[@]:$insertIndex} #先取后面就不用 let "insertIndex++"
     
279. #                echo "afterIndexArr ==========${afterIndexArr[@]}"
     
280.                 local beforeIndexArr=${allSongs[@]:0:$insertIndex}
     
281. #                echo "beforeIndexArr ==========${beforeIndexArr[@]}"
     
282. #                echo "playliststr = ${playlistStr[@]}"
     
283.                 allSongs=(${beforeIndexArr[@]} ${playlistStr[@]} ${afterIndexArr[@]})
     
284. #                echo "all songs ================================="${allSongs[@]}
     
285. #插入歌曲结束
     
286. ################################################################
     
287. ###############################################################
     
288. #改变相应列表的大小
     
289.                 local playlistStrArr=($playlistStr)
     
290. #                echo "playlistIndex =========$playlistIndex        playlistStr  Size = ${#playlistStr[@]}"
     
291.                 let "listSizeArray[$playlistIndex]+=${#playlistStrArr[@]}"
     
292. #                echo "...........................${listSizeArray[@]}"
     
293. #改变相应列表的大小 over
     
294. ###############################################################
     
295.                 IFS=$OLDIFS_1
     
296.                 echo
     
297.                 writeToFile $DATAFILE
     
298.         fi       
     
299.         IFS=$OLDIFS
     
300. }
     
301. 
     
302. 
     
303. #==============================================
     
304. #判断一个播放列表中的歌曲index是否越界
     
305. #参数:$1表示歌曲在一个播放列表中的index，$2表示播放列表Index
     
306. private_isSongIndexInPlayListOverFlow(){
     
307.         local songIndex=$1
     
308.         local playlistIndex=$2
     
309.         echo "playlistIndex==========$playlistIndex"
     
310.         private_isPlayListIndexOverFlow $playlistIndex
     
311.         if [ $? -eq 1 ]
     
312.         then
     
313.                 return 1
     
314.         fi
     
315.         let "songIndex+=0"
     
316.         if [ $? -ne 0 ] || [ $songIndex -lt  0 ] || [ $songIndex -gt ${listSizeArray[$playlistIndex]} ]
     
317.         then
     
318.                 echo "songIndex == $songIndex"
     
319.                 echo "sizearr=========${listSizeArray[@]}"
     
320.                 echo "歌曲Index($songIndex) 错误,index 应该 1 到 ${listSizeArray[$playlistIndex]}"
     
321.                 return 1
     
322.         fi
     
323.         return 0;
     
324. }
     
325. 
     
326. #==============================================
     
327. #显示一个播放列表的详细信息
     
328. #参数:$1表示要显示歌曲的播放列表的index
     
329. private_showAPlayListBasicInfo(){
     
330.         local playlistName="${listNameArray[$1]}"
     
331.         local playlistSize="${listSizeArray[$1]}"
     
332.         echo "================================================"
     
333.         echo "                播放列表名字: $playlistName"
     
334.         echo "                播放列表大小: $playlistSize"       
     
335.         echo "================================================"
     
336. }
     
337. 
     
338. #==============================================
     
339. #从播放列表删除一些歌曲
     
340. #参数:$1表示要显示详细信息的播放列表的index
     
341. delleteSomeSongsFromThePlayList(){
     
342.         showAPlayListAllSongs $1
     
343.         echo "输入要删除的歌曲index范围"
     
344.         echo "用法:index1:index2(0<index1<index2<${listSizeArray[$1]}"
     
345.         echo "输入删除范围"
     
346.         local range
     
347.         read range
     
348.         local OLDIFS=$IFS
     
349.         IFS=":"
     
350.         local argsArr=($range)
     
351.         local arglen=${#argsArr[@]}
     
352.         let "arglen+=0"
     
353.         if [ "$arglen" -ne 2 ]
     
354.         then
     
355.                 echo 参数个数错误
     
356.                 IFS=$OLDIFS
     
357.                 return
     
358.         fi
     
359.         local deleteFromIndex=${argsArr[0]}
     
360.         local deleteToIndex=${argsArr[1]}
     
361.         IFS="$OLDIFS"
     
362.         private_isSongIndexInPlayListOverFlow $deleteFromIndex $1
     
363.         if [ $? -eq 1 ]
     
364.         then
     
365.                 echo "deleteFromIndex($deleteFromIndex) error"
     
366.                 return 1
     
367.         fi
     
368.         echo "..............delete index=$deleteToIndex===......................$1"
     
369.         private_isSongIndexInPlayListOverFlow $deleteToIndex $1
     
370.         if [ $? -eq 1 ]
     
371.         then
     
372.                 return 1
     
373.         fi
     
374.         let "deleteFromIndex-=1"
     
375.         let "deleteToIndex-=1"
     
376.         if [ $deleteFromIndex -gt $deleteToIndex ] #如果from大于to，交换两个值
     
377.         then
     
378.                 local tmpIndex=$deleteFromIndex
     
379.                 deleteFromIndex=$deleteToIndex
     
380.                 deleteToIndex=$tmpIndex
     
381.         fi
     
382.         local beginIndex=0
     
383.         local endIndex=0
     
384.         local step=0
     
385.         while [ "$step" -lt "$1" ]
     
386.         do
     
387.                 echo "step =============$step"
     
388.                 let "beginIndex+=${listSizeArray[$step]}"
     
389.                 let "step++"
     
390.         done
     
391.         echo "删除的开始index==========$beginIndex   endIndex======$endIndex"
     
392.         let "beginIndex+=deleteFromIndex"
     
393.         let "endIndex=beginIndex+deleteToIndex+1"
     
394.         local deleteSize=0
     
395.         let "deleteSize=deleteToIndex-deleteFromIndex+1"
     
396.         echo "删除的开始index==========$beginIndex   endIndex======$endIndex"
     
397. ###############################删除歌曲#####################
     
398.         local afterIndexArr=${allSongs[@]:$endIndex} #先取后面就不用 let "insertIndex++"
     
399. #        echo "afterIndexArr ==========${afterIndexArr[@]}"
     
400.         local beforeIndexArr=${allSongs[@]:0:$beginIndex}
     
401. #        echo "beforeIndexArr ==========${beforeIndexArr[@]}"
     
402. #        echo "playliststr = ${playlistStr[@]}"
     
403.         allSongs=(${beforeIndexArr[@]} ${afterIndexArr[@]})
     
404.        
     
405.         let "listSizeArray[$1]-=deleteSize"
     
406.         writeToFile $DATAFILE       
     
407. }
     
408. #====================================
     
409. #格式化输出所有播放列表       
     
410. #====================================
     
411. private_showPlaylist(){
     
412.         local plName
     
413.         local k=1
     
414. #        echo "before createNew Playlist size :" ${#listNameArray[@]}
     
415.         for plName in "${listNameArray[@]:1}"
     
416.         do
     
417.                 echo "$k-----$plName"
     
418.                 let "k++"
     
419.         done
     
420. }
     
421. 
     
422. #显示当前播放列表
     
423. showCurrentPlayList(){
     
424.         echo "hel"
     
425. }
     
426. #######################显示一个播放列表的所有歌曲 #########
     
427. #===============================
     
428. #显示$1播放列表的所有歌曲
     
429. #参数解释:$1表示播放列表index
     
430. showAPlayListAllSongs(){
     
431.         private_showAPlayListBasicInfo $1
     
432.         local thePlayListStartIndex=0
     
433.         local thePlayListEndIndex=${listSizeArray[$1]}
     
434.         local step=0
     
435.         while [ $step -lt $1 ]
     
436.         do
     
437.                 let "thePlayListStartIndex+=${listSizeArray[$step]}"
     
438.                 let "step++"
     
439.         done
     
440.         let "thePlayListEndIndex+=thePlayListStartIndex"
     
441.         local aSongName
     
442.         local songIndex=0
     
443.         for aSongName in ${allSongs[@]:$thePlayListStartIndex:$thePlayListEndIndex}
     
444.         do
     
445.                 let "songIndex++"
     
446.                 echo "$songIndex-----$aSongName"
     
447.                
     
448.         done
     
449. }
     
450. #=============================
     
451. #新建播放列表
     
452. createPlaylist(){
     
453.         echo "please input playList name:"
     
454.         read plName
     
455.         private_isPlayListExist $plName
     
456.         if [ $? -eq 1 ]
     
457.         then
     
458.                 echo " playlist exist"
     
459.                 return 1
     
460.         else
     
461. #                echo "playlist doesnot exit"
     
462. #                echo "before createNew Playlist size :" ${#listNameArray[@]}
     
463.                 listNameArray=("${listNameArray[@]}" "$plName")
     
464. #                echo "after createNew Playlist size :" ${#listNameArray[@]}
     
465.                 ##########为新建的播放列表在sizArray中指定一个大小0#####
     
466.                 listSizeArray[${#listSizeArray[*]}]=0
     
467.                 echo "新建播放列表$plName成功"
     
468.                 return 0
     
469.         fi
     
470. }
     
471. 
     
472. 
     
473. ###############################################
     
474. #参数解释:$1表示 playingListindex:mode:startIndex
     
475. private_playAPlaylist(){
     
476.         local plName
     
477.         local OLDIFS=$IFSen
     
478.         IFS=":"
     
479.         local arr=($1)
     
480.         local arglen=${#arr[@]}
     
481.         let "arglen+=0"
     
482.         if [ "$arglen" -ne 3 ]
     
483.         then
     
484.                 echo "参数个数错误"       
     
485.                 IFS=$OLDIFS
     
486.                 return
     
487.         fi
     
488.         local needPlayListIndex=${arr[0]}
     
489.         local mode=${arr[1]}
     
490.         local lastStartIndex=${arr[2]}
     
491.         local playingListSize=${listSizeArray[needPlayListIndex]}
     
492.         IFS=$OLDIFS
     
493.         if [ $playingListSize -eq 0 ]
     
494.         then
     
495.                 echo "没有歌曲可播放"
     
496.                 return;
     
497.         fi
     
498. ###########判断播放列表index是否合法####################
     
499.         let "needPlayListIndex+=0"
     
500.         if [ $? -ne 0 ] || [ $needPlayListIndex -lt 1 ] || [ $needPlayListIndex -gt $((${#listNameArray[@]}-1)) ]
     
501.         then
     
502.                 #echo "needPlayListIndex == $needPlayListIndex"
     
503.                 #echo "${#listNameArray[@]}"
     
504.                 echo "index 错误,index 应该 1 到 $((${#listNameArray[@]}-1))"
     
505.                 return
     
506.         fi
     
507. ##########判断模式是否合法################################
     
508.         let "mode+=0"
     
509.         if [ $? -ne 0 ] || [ $mode -lt 0 ] || [ $mode -gt 1 ]
     
510.         then
     
511.                 echo "mode==$mode"
     
512.                 if [ $mode -ne 0 ]
     
513.                 then
     
514.                         echo "模式错误，必须是0或1"
     
515.                         return
     
516.                 fi
     
517.                
     
518.                
     
519.         fi
     
520. ########## startindex 是否合法################################
     
521.         if [ $lastStartIndex -ne 0 ]
     
522.         then
     
523.                 let "lastStartIndex=lastStartIndex+0"
     
524.                 if [ $? -ne 0 ] || [ $lastStartIndex -lt 0 ] || [ $lastStartIndex -gt ${listSizeArray[$needPlayListIndex]} ]
     
525.                 then
     
526.                         echo "{listSizeArray[$needPlayListIndex]} ================${listSizeArray[$needPlayListIndex]}"
     
527.                         echo "lastStartIndex==$lastStartIndex"
     
528.                         echo "startIndex 错误"
     
529.                         return
     
530.                 fi
     
531.         fi
     
532.         listNameArray[0]=$needPlayListIndex
     
533.        
     
534.         local startIndex=0
     
535.         local m=0
     
536.         local startIndex=0
     
537.         local endIndex=${listSizeArray[$needPlayListIndex]}
     
538.                
     
539.         while [ $m -lt $needPlayListIndex ]
     
540.         do
     
541.                 let "startIndex+=${listSizeArray[$m]}"
     
542.                 let "m++"
     
543.         done
     
544.         let "startIndex+=lastStartIndex"
     
545.         let "endIndex+=startIndex"
     
546.         local playFilePath
     
547.         local reacordCurrentPlayingSongIndex=$lastStartIndex
     
548.         if [ $mode -eq 0 ]
     
549.         then
     
550.                 echo "顺序播放"
     
551.                 for playFilePath in ${allSongs[@]:$startIndex:endIndex}
     
552.                 do
     
553.                         allSongs[0]=$reacordCurrentPlayingSongIndex;
     
554.                         writeToFile $DATAFILE
     
555.                         echo "playFilePath ====$playFilePath"
     
556.                         let "reacordCurrentPlayingSongIndex++"       
     
557.                         echo "reacordCurrentPlayingSongIndex == $reacordCurrentPlayingSongIndex"
     
558.                         $(mplayer $playFilePath </dev/null &>/dev/null)
     
559.                 done
     
560.         else
     
561.                 echo "循环播放"
     
562.                 while true
     
563.                 do
     
564.                         for playFilePath in ${allSongs[@]:$startIndex:endIndex}
     
565.                         do
     
566.                                 allSongs[0]=$reacordCurrentPlayingSongIndex;
     
567.                                 writeToFile $DATAFILE
     
568.                                 echo "playFilePath ====$playFilePath"
     
569.                                 let "reacordCurrentPlayingSongIndex++"       
     
570.                                 echo "reacordCurrentPlayingSongIndex == $reacordCurrentPlayingSongIndex"
     
571.                                 $(mplayer $playFilePath </dev/null &>/dev/null)
     
572.                         done
     
573.                 done
     
574.                                
     
575.         fi
     
576.                
     
577.        
     
578. }
     
579. myplayer.tar.gz (6.54 KB, 下载次数: 29)
     2011-11-11 01:03 上传

     点击文件名下载附件
     
     

复制代码

MacLinuXp

#参数介绍：$1 表示一个播放列表的index
PlayAPlaylist(){
        private_showPlaylist
        echo "==========================================================="
                echo "             输入播放列表的index和播放模式"
                echo "             播放模式:0--顺序播放   1--循环播放"
                echo "             用法:1:0"
        echo "==========================================================="
        echo "请输入要播放的列表index和模式"
        local args
        read args
        private_playAPlaylist "$args:0"
}

#================================
#进入某个播放列表
#参数1表示进入的播放列表index
EnterAPlaylist(){
       
        echo "你现在处于播放列表$1中,可执行以下操作"
        select command in "显示该播放列表所有歌曲" "添加歌曲" "删除歌曲" "播放该列表" "排序"  "合并相同名字的歌曲" "回到上一级"  
        do
                echo " you selected $command"
        break
        done
        case $command in
                "显示该播放列表所有歌曲"
                        showAPlayListAllSongs $1 | more       
                ;;
                "添加歌曲"
                        addASongToPlayList $1
                ;;
                "删除歌曲"
                        delleteSomeSongsFromThePlayList $1
                ;;
                "播放该列表"
                        local args="$1:1:0"
                        private_playAPlaylist $args
                ;;
                "回到上一级"
                        EXITAPLAYLIST="true"
                ;;
        esac
}

#===============================
#删除一个播放列表
DeleteAplaylist(){
        showAllPlayLists
        echo "注意，该删除操作不会删除硬盘文件，只会删除播放列表中的引用"
        echo "请输入需要删除播放列表的index:"
        local deleteIndex
        read deleteIndex
        private_isPlayListIndexOverFlow $deleteIndex
        if [ $? -eq 1 ]
        then
                return
        fi

        local deleteStartIndex=0
        local m=0
#        local deleteEndIndex=${listSizeArray[$deleteIndex]}       
        echo "before delte all songs size =======+"${#allSongs[@]}
        while [ $m -lt $deleteIndex ]
        do
                let "deleteStartIndex+=${listSizeArray[$m]}"
                let "m++"
        done
        let "deleteStartIndex+=0"
        let "deleteEndIndex+=deleteStartIndex"
###########删除播放列表名字###############
        unset listNameArray[$deleteIndex]
##########删除播放列表对应的歌曲#############
        allSongs=(${allSongs[@]:0deleteStartIndex} ${allSongs[@]deleteEndIndex})
        local currentPlayingIndex=${listNameArray[0]}
        if [ $currentPlayingIndex -eq $deleteIndex ]
        then
                listNameArray[0]=0
                listSizeArray[0]=0
        fi
        echo "删除成功！！！！！"       
        writeToFile $DATAFILE
}

#=================================================
#显示所有播放列表
showAllPlayLists(){
        echo "============================================="
        private_showPlaylist
        echo "============================================="
}

#=========================================
#操作播放列表
OperatePlaylists(){
        select command in "新建播放列表" "播放一个列表" "进入一个播放列表" "删除播放列表" "查看所有播放列表"  "回到上一级"
        do
                echo " you selected $command"
        break
        done
        case $command in
                "新建播放列表"
                        createPlaylist $plName
                        if [ $? -eq 0 ]
                        then
                                writeToFile $DATAFILE
                        fi       
                ;;
                "进入一个播放列表"
                        showAllPlayLists
                        echo "选择要进入的播放列表序号"
                        local enterPlaylistIndex
                        read enterPlaylistIndex
                        private_isPlayListIndexOverFlow $enterPlaylistIndex
                        if [ $? -eq 1 ]
                        then
                                return
                        fi
                        EXITAPLAYLIST="false"
                        while [ $EXITAPLAYLIST == "false" ]
                        do
                                EnterAPlaylist $enterPlaylistIndex
                        done
                ;;
                "播放一个列表"
                        PlayAPlaylist
                ;;
                "删除播放列表"
                        DeleteAplaylist
                ;;
                "查看所有播放列表"
                        showAllPlayLists
                ;;
                "回到上一级")
                        OPERATEPLAYLISTSOVER="true"
                ;;
        esac
}
#播放列表操作 over
###############################################################################
#########################################################################
#歌曲操作begin

#显示当前播放的歌曲
showCurrentPlayingSong(){
        local currentPlayinglistIndex=${listNameArray[0]}
        local currentPlayingSongIndex=${allSongs[0]}
       
#################播放列表index检查#########################
        if [ $currentPlayinglistIndex -eq 0 ]
        then
                echo "没有记录"
                return
        fi

        if [ $currentPlayingSongIndex -eq 0 ]
        then
                echo "没有记录"
                return
        fi
        let "currentPlayinglistIndex+=0"
        if [ $? -ne 0 ]
        then
                echo "存储格式错误，播放列表存储首项应该是数字"
                return
        fi
        if [ "$currentPlayinglistIndex" -gt ${#listNameArray[@]} ]
        then
                echo "存储格式错误，播放列表数组越界"
                return
        fi
#################播放歌曲index检查#########################
        let "currentPlayingSongIndex+=0"
        if [ $? -ne 0 ]
        then
                echo "存储格式错误，播放歌曲存储首项应该是数字"
                return
        fi
        if [ "$currentPlayingSongIndex" -gt ${#allSongs[@]} ]
        then
                echo "存储格式错误，播放歌曲数组越界"
                return
        fi
        local currentPlayinglistName=${listNameArray[$currentPlayinglistIndex]}
        local m=0
        local sum=0
       
        while [ $m -lt $currentPlayinglistIndex ]
        do
                let "sum+=${listSizeArray[$m]}"
                let "m++"
        done
        local currentPlayingSongInAllSongsIndex=0
        let "currentPlayingSongInAllSongsIndex=sum+currentPlayingSongIndex"
        echo "currentPlayingSongInAllSongsIndex==============$sum"
        local currentPlayingSongName=${allSongs[$currentPlayingSongInAllSongsIndex]}
        echo "currentPlayingSongInAllSongsIndex===========$currentPlayingSongInAllSongsIndex"
        echo "=================================================================="
        echo "当前正在播放的歌曲信息第$currentPlayinglistIndex个播放列表的第$currentPlayingSongIndex首歌曲"
        echo "播放列表名currentPlayinglistName"
        echo "歌曲名currentPlayingSongName"
        echo "=================================================================="
       
}

#######################################################################
#显示帮助

showHelp(){
        echo "======================================================================"
        echo "       该脚本只提供一个播放列表管理，通过调用mpleyer来完成播放，"
        echo "       当处于播放的时候，该脚本失去对播放的控制，不能进行任何操作，"
        echo "       我也试着想改进，但没找到好的方案。"
        echo
        echo "       如果想扩展脚本功能，只要在select里面添加 功能选单，然后 "
        echo "       对数据源进行相应操作就行了"
        echo
        echo "       第一次运行脚本，先选择2来新建个播放列表，因为并没有默认播放列表"
        echo
        echo "       特别注意，对歌曲的添加删除等操作需要选择进入某个播放列表才能进行！"
        echo "       几乎所有的操作都是输入index(数字)进行的!并不支持名字!!!"
        echo
        echo "       最后，该版本可能会有点bug，欢迎指正和改进"
        echo
        echo "       That All______________________^_^______________Have Fun!!!"
        echo "                                          email:zybdfdz@gmail.com"

        echo "======================================================================"
}

#===========================================
#继续上次的播放
GoOn(){
        local args;
        local lastPlayingListIndex=${listNameArray[0]}
        local lastPlayingSongIndex=${allSongs[0]}
        if [ $lastPlayingListIndex -eq 0 ]
        then
                echo "没有记录"
                return
        fi
        args="$lastPlayingListIndex:1lastPlayingSongIndex"
        private_playAPlaylist $args
}

exitPlayer(){
echo "EXITSTATE in ExitPlayer:" $EXITSTATE
EXITSTATE="true"
}
createCommandList(){
        PS3='请选择命令: '
        select command in "继续" "操作播放列表"     "显示当前正在播放的歌曲" "帮助" "退出"
        do
        echo " you selected $command"
        break
        done
        case $command in
        "显示当前正在播放的歌曲")
                showCurrentPlayingSong
        ;;
       
        "操作播放列表")
                OPERATEPLAYLISTSOVER="false"
                while [ "$OPERATEPLAYLISTSOVER" == "false" ]
                do
                        OperatePlaylists
                done
        ;;
        "继续")
                GoOn
        ;;
        "帮助")
                showHelp
        ;;
        "退出")
                exitPlayer
        ;;
        esac
}


#=============================================Main Begin===============
checkEnv
initDataSourceFromFile $DATAFILE
while [ "$EXITSTATE" == "false" ]
do
createCommandList
done

crulat

辛苦，先顶了！
提出两点意见：
1.不要在代码中出现中文，很别扭！
2.代码还可以进一步浓缩和优化！

taojie2000

回复 3# crulat


    论坛里 代码注释 上点中文 不更好吗 ?

     beta 版

MacLinuXp

回复 3# crulat


1.    我开始也是用的英文的，但是贴上来的时候改成中文了，只是为了让它更容易让人明白。
2.   代码肯定还可以优化的，呵呵。

MacLinuXp

顺便问个问题，我用 let "a+=0"
来判断a是否是整数，基本都能很正常的工作，但是当a=0的时候，居然 $?是1 ，让人郁闷阿？不知各位还有没有好方法？

let "a+=0"
if [ "$?" -eq 0 ];then
     echo "sucess"
else
    echo "failed"
fi

MacLinuXp

174 行的样子有个错误  应该改成 “if [ ${#dirOrFile} -le 4 ] || [ ${#dirOrFile} -gt 4 ] && [ "${dirOrFile-4)}" != ".mp3" ]”
255行多余的。。