android学习笔记三

一、Android数据存储,参考http://www.cnblogs.com/ITtangtang/p/3920916.html。

①最熟悉的是文件存储的方式,分两种:

　　1、保存在手机的文件目录中(也可以是缓存目录中,使用了Context对象),

　　2、保存在sd卡上(使用了Environment对象获取SD卡信息,参考:http://www.cnblogs.com/mengdd/p/3742623.html)。

保存文件时的选择:不太重要的可以存在缓存目录中(可以直接被删除);较重要的存在一般目录中;最重要的可以存在SD卡上。

②使用SharedPreferences保存数据同样是保存文件形式,但是是xml格式的文件。

Android解析xml文件的方式:Android提供了多种解析器,但是推荐使用pull解析器。参考:http://blog.csdn.net/liuhe688/article/details/6415593.

③使用SQlite数据库存储数据,和mysql等相比的特点是:在客户端,不用安装服务器。Android中通过两个对象来进行操作:SQLiteOpenHelper,SQLiteDatabase。

参考:http://www.cnblogs.com/Excellent/archive/2011/11/19/2254888.html。

④使用内容提供者:这是应用之间传递数据的方式,一个应用作为提供者,另一个进行查询(这也是使用SQLite数据库,但是是对另一个用的数据库进行CURD操作)。

　　1、提供者将数据操作的类(dao类)继承ContentProviders即可将其暴露,并通过UriMatcher对象设置访问路径且只有uri匹配时才进行相应操作。

　　　　注意:此时的dao类需要实现ContentProviders的抽象方法来进行CURD操作;内容提供者可以设置权限进行控制访问。

　　2、在配置文件中进行配置(包含其本身的声明和权限的配置)

import android.content.ContentProvider;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.net.Uri;

public class PersonContentProvider extends ContentProvider {
    
    private static final String AUTHORITY = "com.itheima28.sqlitedemo.providers.PersonContentProvider";
    private static final int PRESON_INSERT_CODE = 0;    // 操作person表添加的操作的uri匹配码
    private static final int PERSON_DELETE_CODE = 1;
    private static final int PERSON_UPDATE_CODE = 2;
    private static final int PERSON_QUERY_ALL_CODE = 3;
    private static final int PERSON_QUERY_ITEM_CODE = 4;
    
    private static UriMatcher uriMatcher;
    private PersonSQLiteOpenHelper mOpenHelper;        // person表的数据库帮助对象
    
    static {
        uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
        // 添加一些uri(类似于分机号)
        
        // content://com.itheima28.sqlitedemo.providers.PersonContentProvider/person/insert
        uriMatcher.addURI(AUTHORITY, "person/insert", PRESON_INSERT_CODE);
        
        // content://com.itheima28.sqlitedemo.providers.PersonContentProvider/person/delete
        uriMatcher.addURI(AUTHORITY, "person/delete", PERSON_DELETE_CODE);

        // content://com.itheima28.sqlitedemo.providers.PersonContentProvider/person/update
        uriMatcher.addURI(AUTHORITY, "person/update", PERSON_UPDATE_CODE);
        
        // content://com.itheima28.sqlitedemo.providers.PersonContentProvider/person/queryAll
        uriMatcher.addURI(AUTHORITY, "person/queryAll", PERSON_QUERY_ALL_CODE);
        
        // content://com.itheima28.sqlitedemo.providers.PersonContentProvider/person/query/#
        uriMatcher.addURI(AUTHORITY, "person/query/#", PERSON_QUERY_ITEM_CODE);
    }

    //这里可以通过该方法进行初始化,而不用通过构造函数
    @Override
    public boolean onCreate() {
        mOpenHelper = new PersonSQLiteOpenHelper(getContext());
        return true;
    }

    //这个方法是由系统调用的,用于说明返回值的MIME类型
    @Override
    public String getType(Uri uri) {
        switch (uriMatcher.match(uri)) {
        case PERSON_QUERY_ALL_CODE: // 返回多条的MIME-type
            return "vnd.android.cursor.dir/person";
        case PERSON_QUERY_ITEM_CODE: // 返回单条的MIME-TYPE
            return "vnd.android.cursor.item/person";
        default:
            break;
        }
        return null;
    }

    @Override
    public Cursor query(Uri uri, String[] projection, String selection,
            String[] selectionArgs, String sortOrder) {
        SQLiteDatabase db = mOpenHelper.getReadableDatabase();
        switch (uriMatcher.match(uri)) {
        case PERSON_QUERY_ALL_CODE:  // 查询所有人的uri
            if(db.isOpen()) {
                Cursor cursor = db.query("person", projection, selection, selectionArgs, null, null, sortOrder);
                return cursor;
                // db.close(); 返回cursor结果集时, 不可以关闭数据库
            }
            break;
        case PERSON_QUERY_ITEM_CODE:        // 查询的是单条数据, uri末尾出有一个id
            if(db.isOpen()) {
                
                long id = ContentUris.parseId(uri);
                
                Cursor cursor = db.query("person", projection, "_id = ?", new String[]{id + ""}, null, null, sortOrder);

                return cursor;
            }
            break;
        default:
            throw new IllegalArgumentException("uri不匹配: " + uri);
        }
        return null;
    }

    @Override
    public Uri insert(Uri uri, ContentValues values) {
        
        switch (uriMatcher.match(uri)) {
        case PRESON_INSERT_CODE:    // 添加人到person表中
            SQLiteDatabase db = mOpenHelper.getWritableDatabase();
            
            if(db.isOpen()) {
                
                long id = db.insert("person", null, values);
                
                db.close();
                
                return ContentUris.withAppendedId(uri, id);
            }
            break;
        default:
            throw new IllegalArgumentException("uri不匹配: " + uri);
        }
        return null;
    }

    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        switch (uriMatcher.match(uri)) {
        case PERSON_DELETE_CODE:    // 在person表中删除数据的操作
            SQLiteDatabase db = mOpenHelper.getWritableDatabase();
            if(db.isOpen()) {
                int count = db.delete("person", selection, selectionArgs);
                db.close();
                return count;
            }
            break;
        default:
            throw new IllegalArgumentException("uri不匹配: " + uri);
        }
        return 0;
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection,
            String[] selectionArgs) {
        switch (uriMatcher.match(uri)) {
        case PERSON_UPDATE_CODE: // 更新person表的操作
            SQLiteDatabase db = mOpenHelper.getWritableDatabase();
            if(db.isOpen()) {
                int count = db.update("person", values, selection, selectionArgs);
                db.close();
                return count;
            }
            break;
        default:
            throw new IllegalArgumentException("uri不匹配: " + uri);
        }
        return 0;
    }

}

import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.database.Cursor;
import android.net.Uri;
import android.test.AndroidTestCase;
import android.util.Log;

public class TextCase extends AndroidTestCase {

    private static final String TAG = "TextCase";

    public void testInsert() {
        Uri uri = Uri.parse("content://com.itheima28.sqlitedemo.providers.PersonContentProvider/person/insert");
        
        // 内容提供者访问对象
        ContentResolver resolver = getContext().getContentResolver();
        
        ContentValues values = new ContentValues();
        values.put("name", "fengjie");
        values.put("age", 90);
        
        uri = resolver.insert(uri, values);
        Log.i(TAG, "uri: " + uri);
        long id = ContentUris.parseId(uri);
        Log.i(TAG, "添加到: " + id);
    }
    
    public void testDelete() {
        Uri uri = Uri.parse("content://com.itheima28.sqlitedemo.providers.PersonContentProvider/person/delete");
        
        // 内容提供者访问对象
        ContentResolver resolver = getContext().getContentResolver();
        
        String where = "_id = ?";
        String[] selectionArgs = {"21"};
        int count = resolver.delete(uri, where, selectionArgs);
        Log.i(TAG, "删除行: " + count);
    }
    
    public void testUpdate() {
        Uri uri = Uri.parse("content://com.itheima28.sqlitedemo.providers.PersonContentProvider/person/update");
        
        // 内容提供者访问对象
        ContentResolver resolver = getContext().getContentResolver();
        
        ContentValues values = new ContentValues();
        values.put("name", "lisi");
        
        int count = resolver.update(uri, values, "_id = ?", new String[]{"20"});
        Log.i(TAG, "更新行: " + count);
    }
    
    public void testQueryAll() {
        Uri uri = Uri.parse("content://com.itheima28.sqlitedemo.providers.PersonContentProvider/person/queryAll");
        
        // 内容提供者访问对象
        ContentResolver resolver = getContext().getContentResolver();
        
        Cursor cursor = resolver.query(uri, new String[]{"_id", "name", "age"}, null, null, "_id desc");
        
        if(cursor != null && cursor.getCount() > 0) {
            
            int id;
            String name;
            int age;
            while(cursor.moveToNext()) {
                id = cursor.getInt(0);
                name = cursor.getString(1);
                age = cursor.getInt(2);
                Log.i(TAG, "id: " + id + ", name: " + name + ", age: " + age);
            }
            cursor.close();
        }
    }
    
    public void testQuerySingleItem() {
        Uri uri = Uri.parse("content://com.itheima28.sqlitedemo.providers.PersonContentProvider/person/query/#");
        
        // 在uri的末尾添加一个id content://com.itheima28.sqlitedemo.providers.PersonContentProvider/person/query/20
        uri = ContentUris.withAppendedId(uri, 20);
        
        // 内容提供者访问对象
        ContentResolver resolver = getContext().getContentResolver();
        
        Cursor cursor = resolver.query(uri, new String[]{"_id", "name", "age"}, null, null, null);
        
        if(cursor != null && cursor.moveToFirst()) {
            int id = cursor.getInt(0);
            String name = cursor.getString(1);
            int age = cursor.getInt(2);
            cursor.close();
            Log.i(TAG, "id: " + id + ", name: " + name + ", age: " + age);
        }
    }
}

内容提供者是Android四大组件之一,是系统数据向外提供的方式,例如短信,联系人信息等,参考：http://www.2cto.com/kf/201312/261478.html。

和内容提供者相关的是内容观察者,指的是监听一个uri路径上的数据库变化并作出相应操作的类,参考:http://blog.csdn.net/qinjuning/article/details/7047607,注意这篇文章中的其他链接也有些不错的好文。

参考:http://www.it165.net/pro/html/201402/9053.html.

⑤网络数据:Android是一个操作系统,里面各种应用进行网络操作,所以需要多种网络访问方式,而不像web中只有http即可,这就需要所谓的网络编程。参考:http://www.jb51.net/article/44859.htm。

但是移动端网络性能对用户体验影响大,所以通常需要多线程处理网络访问或者其他比较复杂的问题,这就涉及到多线程编程,而在多个线程之间进行消息的传递也是一个必须处理的问题,参考:http://blog.csdn.net/beiminglei/article/details/8474026。

import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

import javax.net.ssl.HttpsURLConnection;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.Toast;

public class MainActivity extends Activity implements OnClickListener {

    private static final String TAG = "MainActivity";
    protected static final int ERROR = 1;
    private EditText etUrl;
    private ImageView ivIcon;
    private final int SUCCESS = 0;
    
    private Handler handler = new Handler() {

        /**
         * 接收消息
         */
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            
            Log.i(TAG, "what = " + msg.what);
            if(msg.what == SUCCESS) {    // 当前是访问网络, 去显示图片
                ivIcon.setImageBitmap((Bitmap) msg.obj);        // 设置imageView显示的图片
            } else if(msg.what == ERROR) {
                Toast.makeText(MainActivity.this, "抓去失败", 0).show();
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        ivIcon = (ImageView) findViewById(R.id.iv_icon);
        etUrl = (EditText) findViewById(R.id.et_url);
        
        findViewById(R.id.btn_submit).setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        final String url = etUrl.getText().toString();
        
        new Thread(new Runnable() {

            @Override
            public void run() {
                Bitmap bitmap = getImageFromNet(url);

//                ivIcon.setImageBitmap(bitmap);        // 设置imageView显示的图片
                if(bitmap != null) {
                    Message msg = new Message();
                    msg.what = SUCCESS;
                    msg.obj = bitmap;
                    handler.sendMessage(msg);
                } else {
                    Message msg = new Message();
                    msg.what = ERROR;
                    handler.sendMessage(msg);
                }
            }}).start();
        
    }

    /**
     * 根据url连接取网络抓去图片返回
     * @param url
     * @return url对应的图片
     */
    private Bitmap getImageFromNet(String url) {
        HttpURLConnection conn = null;
        try {
            URL mURL = new URL(url);    // 创建一个url对象
            
            // 得到http的连接对象
            conn = (HttpURLConnection) mURL.openConnection();
            
            conn.setRequestMethod("GET");        // 设置请求方法为Get
            conn.setConnectTimeout(10000);        // 设置连接服务器的超时时间, 如果超过10秒钟, 没有连接成功, 会抛异常
            conn.setReadTimeout(5000);        // 设置读取数据时超时时间, 如果超过5秒, 抛异常
            
            conn.connect();        // 开始链接
            
            int responseCode = conn.getResponseCode(); // 得到服务器的响应码
            if(responseCode == 200) {
                // 访问成功
                InputStream is = conn.getInputStream();    // 获得服务器返回的流数据
                
                Bitmap bitmap = BitmapFactory.decodeStream(is); // 根据 流数据 创建一个bitmap位图对象
                
                return bitmap;
            } else {
                Log.i(TAG, "访问失败: responseCode = " + responseCode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(conn != null) {
                conn.disconnect();        // 断开连接
            }
        }
        return null;
    }
}

 Android下进行http连接可以使用HttpClient类,但是在Android 6.0(即sdk23）之后移除了相关包,所以不推荐使用,但是好像有的框架依然在使用,可以作为了解,对于Android下使用参考http://liangruijun.blog.51cto.com/3061169/803097/:关于其他的使用参考:http://www.ibm.com/developerworks/cn/opensource/os-httpclient/。注意其中引用的文章列表。

！！！网络访问在模拟器下测试时,访问本机的路径不是127.0.0.1,而是10.0.2.2,或者是局域网中的路径。参考:http://www.cnblogs.com/csulennon/p/3709032.html.

二、android权限

①Android文件权限是linux风格的

②安卓的权限非常细,而且应用需要申请,而用户可以对其进行设定(在模拟器中直接赋予),

具体权限参考:http://www.cnblogs.com/classic/archive/2011/06/20/2085055.html。

三、多线程下载:

上图的要点是:

　　①RandomAccessFile类,这是一个非常适合用于多线程下载的类,因为它带有一个文件指针,可以方便的针对文件的指定位置进行操作。所以多个线程可以分别在不同的位置操作同一个文件而不出线程问题。参考:http://www.2cto.com/kf/201208/149816.html。注意：rwd是直接将读取的文件写入到硬盘上,而rw是先写到内存的缓冲区中,当达到一定量之后在写入硬盘。两者各有优点:一个防止特殊情况丢失下载数据(还没有保存就断网等情况),一个减少io操作。但是下载时使用rwd更好。

　　②上面提到了多线程经常应用在网络等比较耗时的方面,对于网络下载更是如此。但是在Android下的下载使用的依然是j2se中的API,也就是HttpURLConnection类中的方法。具体实现的原理就是HTTP协议中的HTTP头 Range和Content-Range字段。参考:。

所谓的端点下载就是在用一个临时文件同步存储下载数据,只有在下载完成时才删除,所以这个文件就用于判断是否下载完成和记录下载到了那里,便于之后继续下载。

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;

public class MutileThreadDownload {
    /**
     * 线程的数量
     */
    private static int threadCount = 3;

    /**
     * 每个下载区块的大小
     */
    private static long blocksize;

    /**
     * 正在运行的线程的数量
     */
    private static int runningThreadCount;

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        // 服务器文件的路径
        String path = "http://192.168.1.100:8080/ff.exe";
        URL url = new URL(path);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        conn.setConnectTimeout(5000);
        int code = conn.getResponseCode();
        if (code == 200) {
            long size = conn.getContentLength();// 得到服务端返回的文件的大小
            System.out.println("服务器文件的大小：" + size);
            blocksize = size / threadCount;
            // 1.首先在本地创建一个大小跟服务器一模一样的空白文件。
            File file = new File("temp.exe");
            RandomAccessFile raf = new RandomAccessFile(file, "rw");
            raf.setLength(size);
            // 2.开启若干个子线程分别去下载对应的资源。
            runningThreadCount = threadCount;
            for (int i = 1; i <= threadCount; i++) {
                long startIndex = (i - 1) * blocksize;
                long endIndex = i * blocksize - 1;
                if (i == threadCount) {
                    // 最后一个线程
                    endIndex = size - 1;
                }
                System.out.println("开启线程：" + i + "下载的位置：" + startIndex + "~"
                        + endIndex);
                new DownloadThread(path, i, startIndex, endIndex).start();
            }
        }
        conn.disconnect();
    }

    private static class DownloadThread extends Thread {
        private int threadId;
        private long startIndex;
        private long endIndex;
        private String path;

        public DownloadThread(String path, int threadId, long startIndex,
                long endIndex) {
            this.path = path;
            this.threadId = threadId;
            this.startIndex = startIndex;
            this.endIndex = endIndex;
        }

        @Override
        public void run() {
            try {
                // 当前线程下载的总大小
                int total = 0;
                File positionFile = new File(threadId + ".txt");
                URL url = new URL(path);
                HttpURLConnection conn = (HttpURLConnection) url
                        .openConnection();
                conn.setRequestMethod("GET");
                // 接着从上一次的位置继续下载数据
                if (positionFile.exists() && positionFile.length() > 0) {// 判断是否有记录
                    FileInputStream fis = new FileInputStream(positionFile);
                    BufferedReader br = new BufferedReader(
                            new InputStreamReader(fis));
                    // 获取当前线程上次下载的总大小是多少
                    String lasttotalstr = br.readLine();
                    int lastTotal = Integer.valueOf(lasttotalstr);
                    System.out.println("上次线程" + threadId + "下载的总大小："
                            + lastTotal);
                    startIndex += lastTotal;
                    total += lastTotal;// 加上上次下载的总大小。
                    fis.close();
                }

                conn.setRequestProperty("Range", "bytes=" + startIndex + "-"
                        + endIndex);
                conn.setConnectTimeout(5000);
                int code = conn.getResponseCode();
                System.out.println("code=" + code);
                InputStream is = conn.getInputStream();
                File file = new File("temp.exe");
                RandomAccessFile raf = new RandomAccessFile(file, "rw");
                // 指定文件开始写的位置。
                raf.seek(startIndex);
                System.out.println("第" + threadId + "个线程：写文件的开始位置："
                        + String.valueOf(startIndex));
                int len = 0;
                byte[] buffer = new byte[512];
                while ((len = is.read(buffer)) != -1) {
                    RandomAccessFile rf = new RandomAccessFile(positionFile,
                            "rwd");
                    raf.write(buffer, 0, len);
                    total += len;
                    rf.write(String.valueOf(total).getBytes());
                    rf.close();
                }
                is.close();
                raf.close();

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                // 只有所有的线程都下载完毕后 才可以删除记录文件。
                synchronized (MutileThreadDownload.class) {
                    System.out.println("线程" + threadId + "下载完毕了");
                    runningThreadCount--;
                    if (runningThreadCount < 1) {
                        System.out.println("所有的线程都工作完毕了。删除临时记录的文件");
                        for (int i = 1; i <= threadCount; i++) {
                            File f = new File(i + ".txt");
                            System.out.println(f.delete());
                        }
                    }
                }

            }
        }
    }
}

在Android上实现多线程下载的基本原理一样,只是有一些问题需要注意,

　　①下载文件的保存位置,Android项目需要保存在指定的位置:sd卡/Android项目文件路径

　　②多线程之间的信息传递

　　③对用户的提示