#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <dirent.h>  
#include <sys/stat.h>  


#include "JZsdkLib.h"
#include "AudioDeal/AudioDeal.h"
#include "AudioDeal/AudioDealThread/AudioDealThread.h"
#include "./AudioFile_PlayDeal.h"

#include "./AudioMange.h"
#include "Megaphone/Megaphone.h"

#define AUDIO_DIR "/root/sdcard/audio"
#define RECODE_DIR "/root/sdcard/record"

//创建一个歌曲节点
static struct AudioMange_Node *g_AudioList = NULL;
static struct AudioMange_Node *g_AudioListtail = NULL; // 用于跟踪链表的尾部  

static int g_AudioList_Num = 0; //记录链表中一共有几首歌
static int g_AudioList_CurrentNum = 0; //记录播放当前第几首歌

//文件播放线程
static void *FilePlay_data_pthread(void *arg)
{
	unsigned char *FilePath = (unsigned char *) arg;

	Megaphone_MegDataGenFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_ON);
	Megaphone_MegDataGenFinshFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_ON);

	//广播状态开始
	Megaphone_status_Broadcast(AUDIO_PLAY_STATUS_MUSIC);

	int amplifier = JZ_FLAGCODE_ON;
    Megaphone_Amplifier_param(JZ_FLAGCODE_SET, &amplifier);

	int loop = JZ_FLAGCODE_OFF;
	int loop_interval;
	do
	{
		//音频文件播放接口
    	AudioFile_StartPlay_Interface(FilePath);

		Megaphone_param(JZ_FLAGCODE_GET, MEGAPHONE_LOOP, &loop);
		Megaphone_param(JZ_FLAGCODE_GET, MEGAPHONE_LOOP_INTERVAL, &loop_interval);

		//循环播放延时
		while (loop_interval > 0 && (loop == JZ_FLAGCODE_ON) && (Megaphone_MegDataGenFlag(JZ_FLAGCODE_GET, 0) == JZ_FLAGCODE_ON))
		{
			delayMs(50);
			loop_interval -= 50;
		}
		
	} while ( (loop == JZ_FLAGCODE_ON) && (Megaphone_MegDataGenFlag(JZ_FLAGCODE_GET, 0) == JZ_FLAGCODE_ON));

	//释放掉结构体和标志位
	JZsdk_Free(FilePath);

	amplifier = JZ_FLAGCODE_OFF;
    Megaphone_Amplifier_param(JZ_FLAGCODE_SET, &amplifier);


	Megaphone_MegDataGenFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_OFF);
	Megaphone_MegDataGenFinshFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_OFF);

	//广播关闭
	Megaphone_status_Broadcast(JZ_FLAGCODE_OFF);

	JZSDK_LOG_INFO("文件播放线程结束");
}

/*********
 * 
 *  音频文件播放
 * 
**********/
T_JZsdkReturnCode Megaphone_AudioFile_Play(unsigned char *str, unsigned int str_len)
{
	T_JZsdkReturnCode ret;
	if (str_len > 128)
	{
		JZSDK_LOG_ERROR("播放的文件名字长度超过128");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}
	
    //1、查询该名字是否存在于音乐列表中
	struct AudioMange_audio_struct songToFind;
	int index = 0;
	memcpy(songToFind.FileName, str, str_len);
	ret = JZsdk_isSongInAudioList_AndSaveCurrentIndex(g_AudioList, songToFind, &index);
	if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
	{
		JZSDK_LOG_ERROR("播放文件不存在于音乐列表");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}
	g_AudioList_CurrentNum = index;
	JZSDK_LOG_INFO("歌曲跳到%d",g_AudioList_CurrentNum);

	//2、制造一个数据产生函数
	pthread_t flie_play_task;
	pthread_attr_t task_attribute; //线程属性
	pthread_attr_init(&task_attribute);  //初始化线程属性
	pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED);      //设置线程属性

	//文件名参数
	unsigned char *FilePath = NULL;
	int FilePathLen =  (str_len + sizeof(AUDIO_DIR) + 1);
	//留一个长度用于放置文件夹地址
	if(JZsdk_Malloc( (void **)&FilePath, FilePathLen) != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)//如果申请内存失败，malloc会返回一个NULl
	{
		JZSDK_LOG_ERROR("malloc use failure");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;//申请内存失败，错误退出
	}

	//清空参数
	memset (FilePath, 0, FilePathLen);
	snprintf(FilePath, FilePathLen, "%s/%s",AUDIO_DIR,str);

	int pth_ret = pthread_create(&flie_play_task,&task_attribute,FilePlay_data_pthread,(void *)FilePath);	
	if(pth_ret != 0)
	{
		printf("创建文件播放产生线程失败\n");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/*********
 * 
 *  录音文件播放
 * 
**********/
T_JZsdkReturnCode Megaphone_RecordFile_Play(unsigned char *str, unsigned int str_len)
{
	T_JZsdkReturnCode ret;
	if (str_len > 128)
	{
		JZSDK_LOG_ERROR("播放的文件名字长度超过128");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	//2、制造一个数据产生函数
	pthread_t flie_play_task;
	pthread_attr_t task_attribute; //线程属性
	pthread_attr_init(&task_attribute);  //初始化线程属性
	pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED);      //设置线程属性

	//文件名参数
	unsigned char *FilePath = NULL;
	int FilePathLen =  (str_len + sizeof(RECODE_DIR) + 1);
	//留一个长度用于放置文件夹地址
	if(JZsdk_Malloc( (void **)&FilePath, FilePathLen) != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)//如果申请内存失败，malloc会返回一个NULl
	{
		JZSDK_LOG_ERROR("malloc use failure");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;//申请内存失败，错误退出
	}

	//清空参数
	memset (FilePath, 0, FilePathLen);
	snprintf(FilePath, FilePathLen, "%s/%s", RECODE_DIR,str);
	JZSDK_LOG_INFO("播放文件:%s", FilePath);
	int pth_ret = pthread_create(&flie_play_task,&task_attribute,FilePlay_data_pthread,(void *)FilePath);	
	if(pth_ret != 0)
	{
		printf("创建文件播放产生线程失败\n");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/*********
 * 
 *  音频文件链表注销
 * 
**********/
static T_JZsdkReturnCode AudioFile_FreeAudioList()
{
	//清空尾部指针
	g_AudioListtail = NULL; 

	//清空歌曲数量
	g_AudioList_Num = 0; //记录链表中一共有几首歌
	g_AudioList_CurrentNum = 0; //记录播放当前第几首歌

	//释放掉整个链表
	Jzsdk_Free_AndioMange_Node(&g_AudioList);

	g_AudioList = NULL;

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/*********
 * 
 *  音频文件链表刷新
 * 
**********/
T_JZsdkReturnCode AudioFile_FlushAudioList()
{
	//读取audio文件夹，并将歌曲名放入音频列表
	DIR *dir;  
    struct dirent *entry;  
	struct stat fileStat;
    
    struct AudioMange_audio_struct audioInfo;  
	T_JZsdkReturnCode ret;
  
	//检查是否存在audio文件夹，没有则创建一个
    if(JZsdk_check_directory_exists_posix(AUDIO_DIR) != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_ERROR("不存在audio文件夹,创建一个");
        JZsdk_Osal_Mkdir(AUDIO_DIR);
    }

	//确定音频文件夹存在
    if ((dir = opendir(AUDIO_DIR)) == NULL) 
    {  
		JZSDK_LOG_ERROR("音频文件夹获取失败");
		return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
	}

	//查看歌曲存放链表是否有注册过
	if (g_AudioList != NULL)
	{
		AudioFile_FreeAudioList();
	}

	
	while ((entry = readdir(dir)) != NULL) 
	{  
		const unsigned char *filename = entry->d_name;  
		unsigned int fileSize;
		int len = strlen(filename);  

		// // 获取文件状态信息，包括大小  
		// if (stat(filename, &fileStat) == 0) 
		// {  
		// 	fileSize = (unsigned long long)fileStat.st_size;  
		// }
		// else
		// {
		// 	JZSDK_LOG_ERROR("%s文件信息获取错误",filename);
		// 	fileSize = 0;
		// 	continue;
		// }
			
		// 跳过目录和隐藏文件，并检查文件扩展名  
		if (entry->d_type != DT_DIR && strcmp(filename, ".") != 0 && strcmp(filename, "..") != 0) 
		{ 	
			//printf("获取到%s\n",filename);

			// 检查后缀  
			if (JZsdk_strings_suffix_comparison_withLen((const unsigned char *)filename, len, (const unsigned char *)".mp3") == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS
				|| JZsdk_strings_suffix_comparison_withLen((const unsigned char *)filename, len, (const unsigned char *)".wav") == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS
				|| JZsdk_strings_suffix_comparison_withLen((const unsigned char *)filename, len, (const unsigned char *)".flac") == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS
				|| JZsdk_strings_suffix_comparison_withLen((const unsigned char *)filename, len, (const unsigned char *)".m4a") == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS
				|| JZsdk_strings_suffix_comparison_withLen((const unsigned char *)filename, len, (const unsigned char *)".mp2") == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS
				|| JZsdk_strings_suffix_comparison_withLen((const unsigned char *)filename, len, (const unsigned char *)".wma") == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS
				|| JZsdk_strings_suffix_comparison_withLen((const unsigned char *)filename, len, (const unsigned char *)".aac") == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS) 
			{
				// 处理文件  
				memset(&audioInfo, 0, sizeof(audioInfo)); // 清除audioInfo结构  

				//写入文件名
				strncpy(audioInfo.FileName, entry->d_name, JZSDK_FILENAME_SIZE); 

				unsigned char fileDir [256];
				snprintf(fileDir, sizeof(fileDir), "/root/sdcard/audio/%s", filename);

				//写入文件大小
				JZsdk_Fs_ReadFileSize(fileDir, &(audioInfo.FileSize));

				//写入时长信息
				unsigned char cmd[256];
				snprintf(cmd, sizeof(cmd), "ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 %s", fileDir);
				JZsdk_RunSystemCmd_ReturnResult(cmd, &(audioInfo.Time));

				audioInfo.FileNameLen = len;

				// 创建新节点 
				struct AudioMange_Node *newNode = NULL;
				ret = Jzsdk_Create_AndioMange_Node(&newNode, audioInfo);  
				if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS) 
				{  
					JZSDK_LOG_ERROR("存放音乐 %s 失败", entry->d_name); 
					continue;  
				}  

				// 将新节点添加到链表末尾  
				Jzsdk_AddAudioNodeToCircularList(&g_AudioList, &g_AudioListtail, &newNode);

				// 歌曲计数+1
				g_AudioList_Num++;
			}
		}
	}  
  
    closedir(dir);  

	//设置默认播放歌曲
	g_AudioList_CurrentNum = 0;

	//打印一遍已加载的音乐
	JZsdk_PrintfAuidoNode_AudioList(g_AudioList);

	JZSDK_LOG_INFO("刷新歌曲列表已完成");

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
}


/*********
 * 
 *  音频文件初始化
 * 
**********/
T_JZsdkReturnCode Megaphone_AudioFile_Init()
{
	//刷新歌曲列表
	AudioFile_FlushAudioList();
}

/*********************************
 * 
 * 
 *  获取上一首歌的名字
 * 
 * 
 * *********************************/
T_JZsdkReturnCode Megaphone_GetLastSongName(unsigned char *name, int *name_len)
{
	T_JZsdkReturnCode ret;

	//判断歌曲列表是否有歌
	if (g_AudioList_Num == 0)
	{
		JZSDK_LOG_INFO("歌曲列表中没有歌");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	//根据当前的索引值，获取当前的歌曲节点
	struct AudioMange_Node *Current = NULL;	
	ret = getAudioMange_NodeAtIndex(g_AudioList, &Current, g_AudioList_CurrentNum);
	if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
	{
		return ret;
	}
	if (Current == NULL)
	{
		return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
	}

	//根据当前节点，获取上一个节点
	struct AudioMange_Node *LastCurrent = Current->prev;  
    if (LastCurrent == NULL) // 如果没有上一个节点（可能是环形链表且当前是头节点）  
    {  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 或者其他错误码  
    }  

	//根据节点获取名字
	*name_len = LastCurrent->audioInfo.FileNameLen;
	memcpy(name, LastCurrent->audioInfo.FileName, *name_len);

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/*********************************
 * 
 * 
 *  获取下一首歌的名字
 * 
 * 
 * *********************************/
T_JZsdkReturnCode Megaphone_GetNextSongName(unsigned char *name, int *name_len)
{
	T_JZsdkReturnCode ret;

	//判断歌曲列表是否有歌
	if (g_AudioList_Num == 0)
	{
		JZSDK_LOG_INFO("歌曲列表中没有歌");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	//根据当前的索引值，获取当前的歌曲节点
	struct AudioMange_Node *Current = NULL;	
	ret = getAudioMange_NodeAtIndex(g_AudioList, &Current, g_AudioList_CurrentNum);
	if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
	{
		return ret;
	}
	if (Current == NULL)
	{
		return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
	}
	
	//根据当前节点，获取下一个节点
	struct AudioMange_Node *NextCurrent = Current->next;  
    if (NextCurrent == NULL) // 如果没有下一个节点（可能是环形链表且当前是头节点）  
    {  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 或者其他错误码  
    }  

	//根据节点获取名字
	*name_len = NextCurrent->audioInfo.FileNameLen;
	memcpy(name, NextCurrent->audioInfo.FileName, *name_len);

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/*********************************
 * 
 * 
 *  获取某序号下的歌曲名字
 * 
 * 
 * *********************************/
T_JZsdkReturnCode Megaphone_AudioFile_GetAudioNameByIndex(int index, unsigned char *name, int *name_len)
{
	T_JZsdkReturnCode ret ;

	//判断歌曲列表是否有歌
	if (g_AudioList_Num == 0)
	{
		JZSDK_LOG_INFO("歌曲列表中没有歌");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	//判断序号是否在数量内
	if (index > g_AudioList_Num)
	{
		JZSDK_LOG_INFO("歌曲列表中没有第%d首歌",index);
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	//根据当前的索引值，获取当前的歌曲节点
	struct AudioMange_Node *Current = NULL;	
	ret = getAudioMange_NodeAtIndex(g_AudioList, &Current, index);
	if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
	{
		return ret;
	}
	if (Current == NULL)
	{
		return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
	}

	//获取名字，后期这里要改动以下，太危险了, 要限制长度
	memcpy(name, Current->audioInfo.FileName, Current->audioInfo.FileNameLen);
	*name_len = Current->audioInfo.FileNameLen;

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/*********************************
 * 
 * 
 *  删除歌曲
 * 
 * 
 * *********************************/
T_JZsdkReturnCode Megaphone_AudioFile_DeleteAudio(unsigned char *name, int *name_len)
{
	T_JZsdkReturnCode  ret;
	struct AudioMange_audio_struct songToFind;
	struct AudioMange_Node *TempNode;
	int index = 0;
	memcpy(songToFind.FileName, name, *name_len);


	//1、查询该歌曲是否存在于列表中
	ret = JZsdk_isSongInAudioList_AndSaveCurrentNode(g_AudioList,songToFind,TempNode,&index);
	if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE)
	{
		JZSDK_LOG_ERROR("删除失败，该歌曲不存在");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}
	
	//3、删除节点
	ret = deleteAudioMange_NodeByName(&g_AudioList, TempNode->audioInfo.FileName);
	if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
	{
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}
	
	//4、修改列表数
	if (index <= g_AudioList_CurrentNum)
	{
		g_AudioList_CurrentNum--;
	}
	
	g_AudioList_Num--;

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

//获取正在播放的歌曲的名字
T_JZsdkReturnCode AudioMange_Get_FilePlayName(unsigned char *music_name,unsigned int *music_name_length,unsigned int *MusicNum)
{
	T_JZsdkReturnCode ret;
	
	//判断歌曲列表是否有歌
	if (g_AudioList_Num == 0)
	{
		//JZSDK_LOG_INFO("歌曲列表中没有歌");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}
	
	struct AudioMange_Node* Current;
	ret = getAudioMange_NodeAtIndex(g_AudioList, &Current, g_AudioList_CurrentNum);
	if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
	{
		return ret;
	}
	if (Current == NULL)
	{
		return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
	}

	*music_name_length = Current->audioInfo.FileNameLen;
	memcpy(music_name, Current->audioInfo.FileName, *music_name_length);
	if (MusicNum != NULL)
	{
		*MusicNum = g_AudioList_CurrentNum+1;
	}

	//JZSDK_LOG_INFO("*musicnum:%d gnum:%d %s",*MusicNum, g_AudioList_CurrentNum, music_name);

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

//获取歌曲数量
T_JZsdkReturnCode AudioMange_Get_FileNum(unsigned int *num)
{
	*num = g_AudioList_Num;
	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

static int g_AudioFile_SaveAudioFile_len = 0;
static FILE *g_AudioFile_SaveAudioFile_NameFp = NULL;
static int AudioFile_save_flag = 0;

#define SAVE_FILE_DIR "/root/AudioFileTemp.mp3"
static char MP2_SaveFile[1024];

/*
*
*      存储AudioFile文件
*
*/
//1、开始保存
T_JZsdkReturnCode AudioFile_SaveAudioFileStart(char *FileName)
{
    g_AudioFile_SaveAudioFile_len = 0;
    
    memset(MP2_SaveFile, 0, 1024);
    sprintf(MP2_SaveFile, "/root/sdcard/audio/%s", FileName);

    JZSDK_LOG_INFO("上传文件的存储路径为%s",MP2_SaveFile);

    if (g_AudioFile_SaveAudioFile_NameFp != NULL)
    {
        JZSDK_LOG_ERROR("保存AudioFile文件已被打开");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    g_AudioFile_SaveAudioFile_NameFp = fopen(SAVE_FILE_DIR, "w");
    if (g_AudioFile_SaveAudioFile_NameFp == NULL) 
    {
        JZSDK_LOG_INFO("上传audio文件创建失败");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    //接受的名字是正常的 打开标志位
    AudioFile_save_flag = 1;

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

//正在保存传输中的流
T_JZsdkReturnCode AudioFile_SaveAudioFileTrans(char *SaveData, int size)
{
    //如果创建的保存文件为空
    if (g_AudioFile_SaveAudioFile_NameFp == NULL) 
    {
        return -1;
    }
    int writelen;

    //如果创建的保存文件不为空
    if (g_AudioFile_SaveAudioFile_NameFp != NULL) 
    {
        fseek(g_AudioFile_SaveAudioFile_NameFp, g_AudioFile_SaveAudioFile_len, SEEK_SET);   //重设光标位，并写入语音数据
        writelen = fwrite(SaveData, 1, size, g_AudioFile_SaveAudioFile_NameFp);
        if (writelen != size) 
        {
            printf("写入audio文件失败 %d\n", writelen);
        }

        fflush(g_AudioFile_SaveAudioFile_NameFp);
    }

    g_AudioFile_SaveAudioFile_len = g_AudioFile_SaveAudioFile_len +writelen;

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

//传输结束
T_JZsdkReturnCode AudioFile_SaveAudioFileStop(int checkFlag, unsigned char *CheckCode)
{
	T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    char cmd[512];

    //1、通过判断标志位 是否成功创建文件
    if (AudioFile_save_flag == 0)
    {
        JZSDK_LOG_ERROR("未创建AudioFile保存的文件,退出保存操作\n");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    //如果创建的保存文件为空
    if (g_AudioFile_SaveAudioFile_NameFp == NULL) 
    {
		JZSDK_LOG_ERROR("文件打开失败");
		AudioFile_save_flag = 0;
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }
    
    //1、关闭存储的文件
    fflush(g_AudioFile_SaveAudioFile_NameFp);
    fclose(g_AudioFile_SaveAudioFile_NameFp);
    g_AudioFile_SaveAudioFile_NameFp = NULL;
    g_AudioFile_SaveAudioFile_len = 0; //置零长度

	JZsdk_RunSystemCmd("sync");

	if (checkFlag != JZ_FLAGCODE_OFF)
	{
		//校验文件
		if (checkFlag == JZSDK_CHECK_SUM_TYPE_MD5) //md5校验
		{
			//1、获取文件的md5校验码
			ret = JZsdk_CheckSum(JZSDK_CHECK_SUM_TYPE_MD5, SAVE_FILE_DIR, CheckCode, 32);
		}
		else if (checkFlag == JZSDK_CHECK_SUM_TYPE_SRC32)
		{
			//1、获取文件的md5校验码
			ret = JZsdk_CheckSum(JZSDK_CHECK_SUM_TYPE_SRC32, SAVE_FILE_DIR, CheckCode, sizeof(U32_t));
		}
		
		//对比校验码
		if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
		{
			JZSDK_LOG_ERROR("音频文件校验失败");
			memset(cmd,0,sizeof(cmd));
			sprintf(cmd, "rm \"%s\" ",SAVE_FILE_DIR);  
			JZsdk_RunSystemCmd(cmd);  
			AudioFile_save_flag = 0;
			return JZ_ERROR_CHECKCODE_CHECK_ERROR;
		}
	}
	
    memset(cmd,0,sizeof(cmd));
    sprintf(cmd, "mv \"%s\" \"%s\" ",SAVE_FILE_DIR, MP2_SaveFile);    
    printf("cmd:%s\n",cmd);               

    // 执行命令并等待完成  
    int ret_1 = system(cmd);   
    if (ret_1 != 0) 
    {  
        // 命令执行失败，处理错误  
        JZSDK_LOG_ERROR("mp3存储失败"); 
		AudioFile_save_flag = 0;
		ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

	JZsdk_RunSystemCmd("sync");

    //2、关闭标志位
    AudioFile_save_flag = 0;

    //3、刷新音频列表
    Megaphone_Flush_MusicList();//刷新音乐列表 

    return ret;
}

/*****************
 * 
 *  查询歌曲是否存在列表中
 * 
 * 
 * **************/
T_JZsdkReturnCode AudioFile_CheckFile_WhetherInList(unsigned char *str, unsigned int str_len)
{
	T_JZsdkReturnCode	ret;

    //1、查询该名字是否存在于音乐列表中
	struct AudioMange_audio_struct songToFind;
	int index = 0;
	memcpy(songToFind.FileName, str, str_len);
	ret = JZsdk_isSongInAudioList_AndSaveCurrentIndex(g_AudioList, songToFind, &index);
	if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
	{
		JZSDK_LOG_ERROR("播放文件不存在于音乐列表");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/*****************
 * 
 *  查询歌曲信息
 * 
 * 
 * 	**************/
T_JZsdkReturnCode AudioFile_GetAudioInfo(unsigned char *str, unsigned int str_len, struct AudioMange_audio_struct *songToFind)
{
	T_JZsdkReturnCode	ret;

    //1、查询该名字是否存在于音乐列表中
	memset(songToFind->FileName, 0 ,sizeof(songToFind->FileName));
	memcpy(songToFind->FileName, str, str_len);

	ret = JZsdk_isSongInAudioList(g_AudioList, (*songToFind));
	if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
	{
		JZSDK_LOG_ERROR("播放文件不存在于音乐列表 %s", songToFind->FileName);
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	//2、获取歌曲信息
	JZsdk_GetSongInDudioList_AudioInfo(g_AudioList, songToFind);

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}