mp3播放器（四）（从服务器端下载mp3文件+service的应用+SDcard操作）

下载到本地的sd卡中 实现序列化接口 serializable 加一个id 表示接口 通过一个什么样的方式可以把对象变成字节码从内存中发送出去 。。。。。实体类中toString。。。能够把里面的参数都答应出来，直接写类名就行，特别方便 下载要放在线程里面执行，就创建一个内部类

下载文件的过程 1,得到用户所要下载的Mp3文件的名称，靠position获取名字 2,访问网络下载mp3文件 3，通知客户下载的结果

Mp3ListActivity.java

package com.example.mp3player00;

import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;

import service.DownloadService;

import xml.Mp3ListContentHandler;

import model.Mp3Info;

import com.example.download.HttpDownloader;

import android.os.Bundle;
import android.app.Activity;
import android.app.ListActivity;
import android.content.Intent;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.ListView;
import android.widget.SimpleAdapter;

public class Mp3ListActivity extends ListActivity {
    private static final int upadate=1;
    private static final int about=2;
    private List<Mp3Info> mp3Infos=null;
   //以上定义常量，看到值的名字就知道按钮的名字    
   //且为后面修改提供方便
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_mp3_list);
        updateListView();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.activity_mp3_list, menu);
        menu.add(0, 1, 1,R.string.mp3list_update);
        menu.add(0, 2, 2, R.string.mp3list_about);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // TODO Auto-generated method stub
        //System.out.println("--->"+item.getItemId());
        if(item.getItemId()==upadate)
        {
            updateListView();
            
            
        }
        else if(item.getItemId()==about)
        {
            //用户点击了关于按钮
        }
        return super.onOptionsItemSelected(item);
    }
    private SimpleAdapter buildSimpleAdapter(List<Mp3Info> mp3infos){
        //构建Adapter，首先生成一个List对象。List对象里面存的是HashMap，HashMap里面存的是String
        
        List<HashMap<String,String>> list=new ArrayList<HashMap<String,String>>();
        //将Mp3Info迭代出来
        for (Iterator iterator = mp3infos.iterator(); iterator.hasNext();) {
            Mp3Info mp3Info = (Mp3Info) iterator.next();
             //生成一个HashMap对象
            HashMap<String,String> map=new HashMap<String,String>();
            //构造一个map
            map.put("mp3_name", mp3Info.getMp3Name());
            map.put("mp3_size", mp3Info.getMp3Size());
            //构造好map后添加到List中，即将HashMap添加到List中
            list.add(map);
        }
        //生成adapter
        SimpleAdapter simpleAdapter=
     new SimpleAdapter(this,list,R.layout.mp3info_item,new String[]{"mp3_name","mp3_size"},new int[]{R.id.mp3_name,R.id.mp3_size});
        
        
        return simpleAdapter;
        
    }
    private void updateListView(){
        //用户点击了更新按钮
        
        String xml=downloadXML("http://192.168.1.100:8080/mp3/resources.xml");
        //System.out.println("----->"+xml);
        
        
        
            try {
                mp3Infos = parse(xml);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //List<Mp3Info>可以看出一个int，String这样一个类型
            SimpleAdapter simpleAdapter=buildSimpleAdapter(mp3Infos);
            setListAdapter(simpleAdapter);
            
    }
    //写一个单独的下载函数，更加清晰
    private String downloadXML(String urlStr) 
    {
        
        HttpDownloader httpdownloader=new HttpDownloader(); 
        String result=httpdownloader.download(urlStr);
        return result;
    }
    //在这个函数中解析xml
    //首先生成xml解析器
    private List<Mp3Info> parse(String xmlStr) throws IOException 
    {
        List<Mp3Info> info=new ArrayList<Mp3Info>();
        SAXParserFactory saxParserFactory=SAXParserFactory.newInstance();
        try {
            XMLReader xmlReader=saxParserFactory.newSAXParser().getXMLReader();            
            Mp3ListContentHandler  mp3ListContentHandler=new Mp3ListContentHandler(info);
            xmlReader.setContentHandler(mp3ListContentHandler);
            xmlReader.parse(new InputSource(new StringReader(xmlStr)));
            //解析完数据都天道info里面，然后用for循环迭代出来
            for (Iterator iterator = info.iterator(); iterator.hasNext();) {
                Mp3Info mp3Info = (Mp3Info) iterator.next();
                //System.out.println(mp3Info);
            }
            
            
        } catch (SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ParserConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return info;
    
    }
    //第一个是选择的哪一个List，第二个是选择的哪一行，第三个是条目处于的位置，第四个是条目的id
    
    //点击第一个postion是0，就是代表第一行，就是List里面第0个元素，把List看成一个有顺序的链表，链表对象就是mp3infos
    protected void onListItemClick(ListView l, View v, int position, long id) {
        super.onListItemClick(l, v, position, id);
        //根据用户点击的位置来确定获得哪一个mp3info对象
        Mp3Info mp3info=mp3Infos.get(position);
        //System.out.println("mp3info---"+mp3info);//因为已经复写了toString方法
        //在这里启动service
        Intent intent=new Intent();
        //将mp3info放到intent里面去再传到service里面去
        intent.putExtra("mp3info", mp3info);//将mp3info实现序列化
        //设置跳转的目的地
        intent.setClass(this, DownloadService.class);
        //启动Service
        startService(intent);
        
    }
    

}

DownloadService.java

package service;

import com.example.download.HttpDownloader;

import model.Mp3Info;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;

public class DownloadService extends Service {

    @Override
    public IBinder onBind(Intent arg0) {
        // TODO Auto-generated method stub
        return null;
    }
    //Mp3ListActivity里面的,点击一行，onSelectedItem里的onStartService ,调用这里的onstart()
    @Override
    public void onStart(Intent intent, int startId) {
        // TODO Auto-generated method stub
        //从intent里面将mp3info取出来
        Mp3Info mp3info=(Mp3Info) intent.getSerializableExtra("mp3info");
        System.out.println("service----->"+mp3info);
        DownloadThread downloadThread=new DownloadThread(mp3info);
        Thread thread=new Thread(downloadThread);
        thread.start();
        super.onStart(intent, startId);
    }
    //onstar执行好，生成一个线程来执行下载
    //创建线程的内部类
    class DownloadThread implements Runnable{
        //要能接受mp3info对象，创建构造函数
        private Mp3Info mp3Info=null;
        public DownloadThread(Mp3Info mp3Info){
            this.mp3Info=mp3Info;
            System.out.println("---in thread"+mp3Info.getMp3Name());
        }
        //在run里面实现下载
            @Override
      public void run() {
        System.out.println("---in thread2"+mp3Info.getMp3Name());
        // TODO Auto-generated method stub
        //下载地址C:\apache-tomcat-7.0.42\webapps\mp3
        String mp3Url="http://192.168.1.100:8080/mp3/"+mp3Info.getMp3Name();
        HttpDownloader httpDownloader=new HttpDownloader();
        int result=httpDownloader.downFile(mp3Url,"mp3/", mp3Info.getMp3Name());//放在sdcard里面哪个文件夹里
    }
    }



}

HttpDownloader.java

package com.example.download;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import utils.FileUtils;



public class HttpDownloader {

    /**
     * 根据URL下载文件，前提是这个文件当中的内容是文本，函数的返回值就是文件当中的内容
     * 1.创建一个URL对象
     * 2.通过URL对象，创建一个HttpURLConnection对象
     * 3.得到InputStram
     * 4.从InputStream当中读取数据
     * @param urlStr
     * @return
     */
    public String download(String urlStr) {
        StringBuffer sb = new StringBuffer();
        String line = null;
        BufferedReader buffer = null;
        try {
            // 创建一个URL对象
            URL url = new URL(urlStr);
            // 创建一个Http连接
            HttpURLConnection urlConn = (HttpURLConnection) url
                    .openConnection();
            // 使用IO流读取数据
            buffer = new BufferedReader(new InputStreamReader(urlConn
                    .getInputStream()));
            while ((line = buffer.readLine()) != null) {
                sb.append(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                buffer.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return sb.toString();
    }
    public int downFile(String urlStr, String path, String fileName) {
        InputStream inputStream = null;
        try {
            FileUtils fileUtils = new FileUtils();
            
            if (fileUtils.isFileExist(  fileName,path)) {
                return 1;
            } else {
                inputStream = getInputStreamFromUrl(urlStr);
                System.out.println("urlStr----->"+urlStr+"path-->"+path+"filename-->"+fileName);
                File resultFile = fileUtils.write2SDFromInput(path,fileName, inputStream);
                System.out.println("httpDownloader---->"+resultFile);
                if (resultFile == null) {
                    return -1;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        } finally {
            try {
                inputStream.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return 0;
    }
    public InputStream getInputStreamFromUrl(String urlStr)
            throws MalformedURLException, IOException {
        URL url = new URL(urlStr);
        HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
        InputStream inputStream = urlConn.getInputStream();
        return inputStream;
    }
}

FileUtils.java

package utils;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import android.os.Environment;

public class FileUtils {
    private String SDPATH;

    public String getSDPATH() {
        return SDPATH;
    }
    public FileUtils() {
        //得到当前外部存储设备的目录
        // /SDCARD
        SDPATH = Environment.getExternalStorageDirectory().getAbsolutePath()+File.separator;
        System.out.println("判断SDCard是否存在，是否有可读权限："
        + Environment.MEDIA_MOUNTED.endsWith(Environment.getExternalStorageState()));
    }
    /**
     * 在SD卡上创建文件
     * 
     * @throws IOException
     * 在哪个目录上生成这个文件，文件的名字
     */
    public File creatSDFile(String fileName,String dir) throws IOException {
        File file = new File(SDPATH+dir + fileName);
        System.out.println("file--->"+file);
        file.createNewFile();
        return file;
    }
    
    /**
     * 在SD卡上创建目录
     * 
     * @param dirName
     */
    public File creatSDDir(String dir) {
        File dirFile = new File(SDPATH + dir+File.separator);
        System.out.println("creatSDDir?---->"+dirFile.mkdirs());
        return dirFile;
    }

    /**
     * 判断SD卡上的文件夹是否存在
     */
    public boolean isFileExist(String fileName,String path){
        File file = new File(SDPATH + path+File.separator+fileName);
        return file.exists();
    }
    
    /**
     * 将一个InputStream里面的数据写入到SD卡中
     */
    public File write2SDFromInput(String path,String fileName,InputStream input){
        File file = null;
        OutputStream output = null;
        try{
            creatSDDir(path);
            file = creatSDFile( fileName,path );
            output = new FileOutputStream(file);
            byte buffer [] = new byte[4 * 1024];
            int temp;
            while((temp=input.read(buffer))!= -1){
                output.write(buffer,0,temp);
            }
            output.flush();
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            try{
                output.close();
            }
            catch(Exception e){
                e.printStackTrace();
            }
        }
        return file;
    }

}

Mp3ContentHandler.java

package xml;

import java.util.List;

import model.Mp3Info;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
//解析
//内容处理器 ContentHandler 接口是解析xm的主体
//handler使用的是adapter的设计模式
//Adapter是连接后端数据和前端显示的适配器接口，
//是数据和UI（View）之间一个重要的纽带。在常见的View(ListView,GridView)等地方都需要用到Adapter
public class Mp3ListContentHandler extends DefaultHandler {
    private List<Mp3Info> info=null;//这边每次解析resource标签都会放入一个Mp3Info对象当中 ，一个标签就是一resource,再把每个对象放入List
    //Mp3ListActivity在调用此类的时候会生成List并且传进来
    private Mp3Info mp3info=null;//mp3info里面就是存放resource的值
    private String tagname;
    
    //添加get和set方便访问
    public List<Mp3Info> getInfo() {
        return info;
    }

    public void setInfo(List<Mp3Info> info) {
        this.info = info;
    }
    
    //Mp3ListActivity在调用此类的时候会生成List并且传进来
    public Mp3ListContentHandler(List<Mp3Info> info) {
        super();
        this.info = info;
    }

    @Override
   //遇到id这个标签，将值赋给Mp3Info的id属性
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        // TODO Auto-generated method stub
        super.characters(ch, start, length);
        String temp=new String(ch,start,length);
        if(tagname.equals("id"))
        {
            mp3info.setId(temp);//如果标签是“id”，就把值赋予mp3info对象中的id变量中
        }
        else if(tagname.equals("mp3.name"))
        {
            mp3info.setMp3Name(temp);
        }
        else if(tagname.equals("mp3.size"))
        {
            mp3info.setMp3Size(temp);
        }
        else if(tagname.equals("Irc.name"))
        {
            mp3info.setIrcName(temp);
        }
        else if(tagname.equals("Irc.size"))
        {
            mp3info.setIrcSize(temp);
        }
        
    }

    @Override
    public void endDocument() throws SAXException {
        // TODO Auto-generated method stub
        super.endDocument();
    }

    @Override
    //标签解析结束
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        // TODO Auto-generated method stub
        super.endElement(uri, localName, qName);
        if(qName.equals("resource"))//这里用qName而不是tagname
        {
            info.add(mp3info);//如果遇到resource结尾，那么就把这个对象放入到List中
        }
        tagname="";
    }

    @Override
    public void startDocument() throws SAXException {
        // TODO Auto-generated method stub
        super.startDocument();
    }

    @Override
    //开始解析标签
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        // TODO Auto-generated method stub
        super.startElement(uri, localName, qName, attributes);
        this.tagname=localName;
        if(tagname.equals("resource"))
        {
            mp3info=new Mp3Info();
        }
    }

}

Mp3Info.java

package model;

import java.io.Serializable;

/**
 * 把每一个<rescource>看成一个对象 mp3info对象 建一个实体类，代表现实中一个实体
 * Mp3info实体类
 * @author kyx
 */
public class Mp3Info implements Serializable{
   /**
     * 实现序列化接口
     * 可以把对象变成字节码从内存中发送出去
     */
    private static final long serialVersionUID = 1L;
private String id;
   private String mp3Name;
   private String mp3Size;
   private String IrcName;
   private String IrcSize;
public String getId() {
    return id;
}
public void setId(String id) {
    this.id = id;
}
public String getMp3Name() {
    return mp3Name;
}
public void setMp3Name(String mp3Name) {
    this.mp3Name = mp3Name;
}
public String getMp3Size() {
    return mp3Size;
}
public void setMp3Size(String mp3Size) {
    this.mp3Size = mp3Size;
}
public String getIrcName() {
    return IrcName;
}
public void setIrcName(String ircName) {
    IrcName = ircName;
}
public String getIrcSize() {
    return IrcSize;
}
public void setIrcSize(String ircSize) {
    IrcSize = ircSize;
}
//还要生成一些构造函数，构造函数起码要有两个，一个是带参数的，一个是不带参数的
public Mp3Info(String id, String mp3Name, String mp3Size, String ircName,
        String ircSize) {
    super();
    this.id = id;
    this.mp3Name = mp3Name;
    this.mp3Size = mp3Size;
    IrcName = ircName;
    IrcSize = ircSize;
}
//不带参数的的构造函数
public Mp3Info() {
    super();
}
@Override
public String toString() {
    return "Mp3Info [id=" + id + ", mp3Name=" + mp3Name + ", mp3Size="
            + mp3Size + ", IrcName=" + IrcName + ", IrcSize=" + IrcSize + "]";
}
//toString方便测试鉴定
}

Manifest

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.mp3player00"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="4"
        android:targetSdkVersion="4" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.example.mp3player00.Mp3ListActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service android:name="service.DownloadService"></service>
    </application>
    <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
 <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"></uses-permission> 
</manifest>

调试中的问题

无法创建路径

问题根源

成功下载mp3文件