Android 下log的使用总结

第一篇：Android 下log的使用总结

Android 下log的使用总结

一:在源码开发模式下

1:包含头文件:

1.#include

2:定义宏LOG_TAG

1.#define LOG_TAG “MY LOG TAG”

3:链接log对应的.so库

在Android.mk文件中加入如下语句:

1.LOCAL_SHARED_LIBRARIES +=

2.libcutils

接下来就可以直接使用LOGD来打印log信息了.二:在NDK开发模式下

1:包含头文件:

1.#include

2:定义宏LOG_TAG

1.#define LOG_TAG “MY LOG TAG”

2.#define LOGD(...)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)3:链接log对应的.so库

在Android.mk文件中加入如下语句:

1.LOCAL_LDLIBS :=-llog

接下来就可以直接使用LOGD来打印log信息了.三：在Java代码中

1:导入包

1.import android.util.Log;

2：使用

1.private static final String TAG = “your_tag”;

2.Log.d(TAG,“show something”);

在程序运行过程中可以通过adb shell下的logcat指令看到相应的内容。或在Eclipse下的ADT的LogCat窗口中看到相应的内容了.

第二篇：android 使用MediaCodec 编解码总结

android 使用MediaCodec 编解码总结

本文将主要介绍在安卓中调用MediaCodec类实现视频文件的硬解码，以及如何将以byte[]类型存储的图像数据通过硬编码合成视频文件。1.MediaCodec类的编解码原理 参考链接：https://developer.Android.com/reference/android/media/MediaCodec.html 工作流是这样的： 以编码为例，首先要初始化硬件编码器，配置要编码的格式、视频文件的长宽、码率、帧率、关键帧间隔等等。这一步叫configure。之后开启编码器，当前编码器便是可用状态，随时准备接收数据。下一个过程便是编码的running过程，在此过程中，需要维护两个buffer队列，InputBuffer 和OutputBuffer，用户需要不断出队InputBuffer(即dequeueInputBuffer)，往里边放入需要编码的图像数据之后再入队等待处理，然后硬件编码器开始异步处理，一旦处理结束，他会将数据放在OutputBuffer中，并且通知用户当前有输出数据可用了，那么用户就可以出队一个OutputBuffer，将其中的数据拿走，然后释放掉这个buffer。结束条件在于end-of-stream这个flag标志位的设定。在编码结束后，编码器调用stop函数停止编码，之后调用release函数将编码器完全释放掉，整体流程结束。

2.视频解码程序示例 代码来源于

Android: MediaCodec视频文件硬件解码以下所有代码可以在此处下载[java] view plain copy

print?

package com.example.guoheng_iri.helloworld;

import android.graphics.ImageFormat;

import android.graphics.Rect;

import android.graphics.YuvImage;

import android.media.Image;

import android.media.MediaCodec;

import android.media.MediaCodecInfo;

import android.media.MediaExtractor;

import android.media.MediaFormat;

import android.util.Log;

import java.io.File;import java.io.FileOutputStream;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.util.concurrent.LinkedBlockingQueue;

public class VideoDecode {

private static final String TAG = “VideoToFrames”;

private static final boolean VERBOSE = true;

private static final long DEFAULT_TIMEOUT_US = 10000;

private static final int COLOR_FormatI420 = 1;

private static final int COLOR_FormatNV21 = 2;

public static final int FILE_TypeI420 = 1;

public static final int FILE_TypeNV21 = 2;

public static final int FILE_TypeJPEG = 3;

private final int decodeColorFormat = MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible;

private int outputImageFileType =-1;

private String OUTPUT_DIR;

public int ImageWidth=0;

public int ImageHeight=0;

MediaExtractor extractor = null;

MediaCodec decoder = null;

MediaFormat mediaFormat;

public void setSaveFrames(String dir, int fileType)throws IOException {

if(fileType!= FILE_TypeI420 && fileType!= FILE_TypeNV21 && fileType!= FILE_TypeJPEG){

throw new IllegalArgumentException(“only support FILE_TypeI420 ” + “and FILE_TypeNV21 ” + “and FILE_TypeJPEG”);

}

outputImageFileType = fileType;

File theDir = new File(dir);

if(!theDir.exists()){

theDir.mkdirs();

} else if(!theDir.isDirectory()){

throw new IOException(“Not a directory”);

}

OUTPUT_DIR = theDir.getAbsolutePath()+ “/”;

}

public void VideoDecodePrepare(String videoFilePath){

extractor = null;

decoder = null;

try {

File videoFile = new File(videoFilePath);

extractor = new MediaExtractor();

extractor.setDataSource(videoFile.toString());

int trackIndex = selectTrack(extractor);

if(trackIndex < 0){

throw new RuntimeException(“No video track found in ” + videoFilePath);

}

extractor.selectTrack(trackIndex);

mediaFormat = extractor.getTrackFormat(trackIndex);

String mime = mediaFormat.getString(MediaFormat.KEY_MIME);

decoder = MediaCodec.createDecoderByType(mime);

showSupportedColorFormat(decoder.getCodecInfo().getCapabilitiesForType(mime));

if(isColorFormatSupported(decodeColorFormat, decoder.getCodecInfo().getCapabilitiesForType(mime))){

mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, decodeColorFormat);

Log.i(TAG, “set decode color format to type ” + decodeColorFormat);

} else {

Log.i(TAG, “unable to set decode color format, color format type ” + decodeColorFormat + “ not supported”);

}

decoder.configure(mediaFormat, null, null, 0);

decoder.start();

} catch(IOException ioe){

throw new RuntimeException(“failed init encoder”, ioe);

}

}

public void close(){

decoder.stop();

decoder.release();

if(extractor!= null){

extractor.release();

extractor = null;

}

}

public void excuate()

{

try {

decodeFramesToImage(decoder, extractor, mediaFormat);

}finally {

// release encoder, muxer, and input Surface

close();

}

}

private void showSupportedColorFormat(MediaCodecInfo.CodecCapabilities caps){

System.out.print(“supported color format: ”);

for(int c : caps.colorFormats){

System.out.print(c + “t”);

}

System.out.println();

}

private boolean isColorFormatSupported(int colorFormat, MediaCodecInfo.CodecCapabilities caps){

for(int c : caps.colorFormats){

if(c == colorFormat){

return true;

}

}

return false;

}

public void decodeFramesToImage(MediaCodec decoder, MediaExtractor extractor, MediaFormat mediaFormat){

MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();

boolean sawInputEOS = false;

boolean sawOutputEOS = false;

final int width = mediaFormat.getInteger(MediaFormat.KEY_WIDTH);

final int height = mediaFormat.getInteger(MediaFormat.KEY_HEIGHT);

ImageWidth=width;

ImageHeight=height;

int outputFrameCount = 0;

while(!sawOutputEOS){

if(!sawInputEOS){

int inputBufferId = decoder.dequeueInputBuffer(DEFAULT_TIMEOUT_US);

if(inputBufferId >= 0){

ByteBuffer inputBuffer = decoder.getInputBuffer(inputBufferId);

int sampleSize = extractor.readSampleData(inputBuffer, 0);//将一部分视频数据读取到inputbuffer中，大小为sampleSize

if(sampleSize < 0){

decoder.queueInputBuffer(inputBufferId, 0, 0, 0L, MediaCodec.BUFFER_FLAG_END_OF_STREAM);

sawInputEOS = true;

} else {

long presentationTimeUs = extractor.getSampleTime();

decoder.queueInputBuffer(inputBufferId, 0, sampleSize, presentationTimeUs, 0);

extractor.advance();//移动到视频文件的下一个地址

}

}

}

int outputBufferId = decoder.dequeueOutputBuffer(info, DEFAULT_TIMEOUT_US);

if(outputBufferId >= 0){

if((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM)!= 0){

sawOutputEOS = true;

}

boolean doRender =(info.size!= 0);

if(doRender){

outputFrameCount++;

Image image = decoder.getOutputImage(outputBufferId);

System.out.println(“image format: ” + image.getFormat());

if(outputImageFileType!=-1){

String fileName;

switch(outputImageFileType){

case FILE_TypeI420:

fileName = OUTPUT_DIR + String.format(“frame_%05d_I420_%dx%d.yuv”, outputFrameCount, width, height);

dumpFile(fileName, getDataFromImage(image, COLOR_FormatI420));

break;

case FILE_TypeNV21:

fileName = OUTPUT_DIR + String.format(“frame_%05d_NV21_%dx%d.yuv”, outputFrameCount, width, height);

dumpFile(fileName, getDataFromImage(image, COLOR_FormatNV21));

break;

case FILE_TypeJPEG:

fileName = OUTPUT_DIR + String.format(“frame_%05d.jpg”, outputFrameCount);

compressToJpeg(fileName, image);

break;

}

}

image.close();

decoder.releaseOutputBuffer(outputBufferId, true);

}

}

}

}

private static int selectTrack(MediaExtractor extractor){

int numTracks = extractor.getTrackCount();

for(int i = 0;i < numTracks;i++){

MediaFormat format = extractor.getTrackFormat(i);

String mime = format.getString(MediaFormat.KEY_MIME);

if(mime.startsWith(“video/”)){

if(VERBOSE){

Log.d(TAG, “Extractor selected track ” + i + “(” + mime + “): ” + format);

}

return i;

}

}

return-1;

}

private static boolean isImageFormatSupported(Image image){

int format = image.getFormat();

switch(format){

case ImageFormat.YUV_420_888:

case ImageFormat.NV21:

case ImageFormat.YV12:

return true;

}

return false;

}

public static byte[] getGrayFromData(Image image, int colorFormat){

if(colorFormat!= COLOR_FormatI420 && colorFormat!= COLOR_FormatNV21){

throw new IllegalArgumentException(“only support COLOR_FormatI420 ” + “and COLOR_FormatNV21”);

}

if(!isImageFormatSupported(image)){

throw new RuntimeException(“can't convert Image to byte array, format ” + image.getFormat());

}

Image.Plane[] planes = image.getPlanes();

int i = 0;

ByteBuffer buffer = planes[i].getBuffer();

byte[] data = new byte[buffer.remaining()];

buffer.get(data, 0, data.length);

if(VERBOSE)Log.v(TAG, “Finished reading data from plane ” + i);

return data;

}

public static byte[] getDataFromImage(Image image, int colorFormat){

if(colorFormat!= COLOR_FormatI420 && colorFormat!= COLOR_FormatNV21){

throw new IllegalArgumentException(“only support COLOR_FormatI420 ” + “and COLOR_FormatNV21”);

}

if(!isImageFormatSupported(image)){

throw new RuntimeException(“can't convert Image to byte array, format ” + image.getFormat());

}

Rect crop = image.getCropRect();

int format = image.getFormat();

int width = crop.width();

int height = crop.height();

Image.Plane[] planes = image.getPlanes();

byte[] data = new byte[width * height * ImageFormat.getBitsPerPixel(format)/ 8];

byte[] rowData = new byte[planes[0].getRowStride()];

int channelOffset = 0;

int outputStride = 1;

for(int i = 0;i < planes.length;i++){

switch(i){

case 0:

channelOffset = 0;

outputStride = 1;

break;

case 1:

if(colorFormat == COLOR_FormatI420){

channelOffset = width * height;

outputStride = 1;

} else if(colorFormat == COLOR_FormatNV21){

channelOffset = width * height;

outputStride = 2;

}

break;

case 2:

if(colorFormat == COLOR_FormatI420){

channelOffset =(int)(width * height * 1.25);

outputStride = 1;

} else if(colorFormat =

第三篇：Android总结

Android四大组件：

Activity—表现屏幕界面

Service—后台服务

BroadcastReceiver—实现广播机制

ContentProvider—实现数据存储

Intent类：用来启动程序并传递信息的类

用于Activity、Receiver、Service之间进行交互的类，通过无参构造方法创建对象，增加其action、category、data、extra等属性进行信息传递，并通过Activity中的startActivity(Intent intent)进行界面的跳转；通过Context中的StartService（Intent intent）进行服务跳转；通过Context中的registerReceive（Intent intent）对广播进行注册，并通过sendBroadcast()进行无序消息发送，或可以通过SendOrderedBroadcast（）进行有序的消息发送。Handler类：

用来发送和处理消息，并配合主线程完成UI的更新；消息Message/Runnable传递通过MessageQueue（消息队列,先进先出）进行传递，并通过Lopper进行接收，传递的消息可以为Message对象，也可以是Runnable对象；接收方法通过HandleMessage(Message msg)进行获取。SharedPreferences类：

一般用于第一次登录时的设置，或者是各个界面的一些小型格式设置，如字体等。是本地的小型共享数据库，可以通过Context的静态方法getSharedPreferences获得其对象，对象内的值均为键值对进行储存。通过SharedPreferences对象调用editor（）获取SharedPreferences.Editor对象，向共享数据库中增加数据，putString(),并提交数据，commit();通过SharedPreferences对象获取共享数据库中的数据，getString()。

ViewPager：实现界面滑动的类；

通过设置OnPagerChangedListener设置ViewPager的监听事件；

实现流程：

①布局文件中设置ViewPager控件；

②代码中进行绑定控件；

③通过继承PagerAdapter抽象类进行设置适配器，并传递数据源；

④适配器中实现两个抽象方法，两个重写方法：getCount()—获取滑动界面的数量，isViewFromObject()—判断视图是否是来自于Object文件中;重写两个方法，分别为destoryItem—销毁指定位置的视图；InstantiateItem()，设置指定位置的视图；

Timer与TimerTask类：

Timer为计时器的类，通过无参构造方法可以获取对象，通过Timer.schedule（TimerTask task,long time）进行设置多久后执行某任务，当任务执行完后，取消计时的功能，Timer.cancle()；TimerTask类为抽象类，实例化时，必须重写run方法；执行的内容，均在run方法中进行设置，并且执行时，已在子线程中进行执行。自定义View：用到的类有Paint、Canvas、Spec、SpecF、Path、View.MeasureSpec、Timer、TimerTask；

抽象类，通过子类继承，获取对象；在布局文件中绑定后，通过代码，设置自定义View的属性；自定义View中，通过重写OnMeasure方法，对布局文件中的尺寸进行测量，并由View中的setMeasureDimenson()方法，进行数据的保存；通过重写Ondraw方法，进行绘图；当需要绘制动态图形时，使用计时器Timer的schedule(TimerTask,long time,delay time2)方法，在time时间后，每隔time2时间，重写执行run方法中的内容；将耗时的操作设置在run方法中，并通过View中的invalidate()方法刷新主线程中的绘的图形，通过postInvalidate()刷新子线程中的图形。数据库：

常用的数据库有Oracle,需要安装和配置的大型收费数据库；MySQL是中型数据库，同样需要安装配置，但不需要收费；Sqlite是小型免费的嵌入式数据库，占用内存低，最新版本为3.0。Sqlite数据库需要通过SqliteDatabaseOpenHelper进行创建数据库，并通过SqliteDatabase进行数据库的操作。辅助类是抽象类，通过继承，重写两个方法，并在子类的构造方法中通过OpenHelper的构造方法(Context context,String SqlName,SqliteDatabase.CursorFactory factory,int version)进行数据库的创建，在onCreate方法中，进行数据库表的创建，在onUpdate中进行数据库的版本更新。在数据库的操作类中，执行exect方法，通过sql语句对数据库进行操作。Create table student(_id integer primary key auto increament ,name text);insert into student(_id,name)values(1,zx);delete from student where _id=1;update student set _id=2 where name=zx;select *from student;ListView、GridView适配器的优化：

将布局文件中的控件进行封装，当视图加载时，判断可变视图是否存在，当不存在时，通过布局文件获取视图，并新建封装类，将地址通过setTag()进行发送；当视图存在时，重复利用地址—getTag()。反射：

存储数据的方式：

共享数据库、数据库、文件、网络、内容提供者

广播：

广播传播时，需要接收者、发送者、广播频道；根据发送者的发送方式不同，分为有序广播、无序广播；有序广播为接收者有接收顺序，根据设置的优先级不同，确定先后顺序，接收者同时也是发送者，向后面的广播发送消息，发送过程中，可以添加信息，也可以停止广播的传输；无序广播，接收者之间无联系，均从发送者处接收信息；广播在传输过程中，不能被添加信息，也不可能被停止。广播在发送前，需要对接收者进行注册，注册方式有两种，动态注册、静态注册。动态注册，是在代码中进行，通过Context对象调用静态方法进行注册，所有的广播均可以用动态注册，其生命周期依赖于应用，相对于静态注册，比较节省内存；静态方法在清单文件中进行注册，部分系统广播不能通过静态注册进行，其生命周期依赖于系统，当系统启动，即运行接收广播，较耗内存。广播接收者需要继承BroadcastReceiver，并实现抽象方法onReceive()，通过回调接口，进行数据的传输。注意：广播发送前，必须进行接收者的注册，并且，当显示跳转时，不需要意图过滤器。安卓布局：九种布局

线性布局，水平或垂直方向两种格式，主要特点为权重，即规定各控件在视图中的占有的比例；

相对布局，相对于父控件或兄弟控件的布局，各控件需指定相对位置； 绝对布局，指定各控件在视图中的绝对位置，几乎不再使用； 表格布局，子布局放在行中，列由控件表示（TableRow）； 帧布局：覆盖前面布局的布局，一般用于暂停按钮等； 风格布局：可以跨行、跨列的布局，占满换行；

左右侧滑：可以实现左右侧滑，通过设置主菜单和二级菜单设置左右两个菜单； 下拉刷新：设置下拉刷新、上拉加载的功能； 抽屉布局；

安卓版本及对应的API：

1.6—4；2—7；3—11；4—15；4.3—18；5—20；5.1—21；6—23；7—25； 安卓四层架构：

应用层：Java语言开发，主要从事App开发；

运行库层：Java语言与C语言，View视图、管理类等的开发； 架构层：C语言与Linux语言，各种框架、浏览器等； 内核层：Linux、C语言，开发各种驱动； 安卓四大组件：

Activity：界面，实现程序与用户之间的交换，有自己的生命周期，七个生命周期；4种启动模式 Service：

BroadcastReceive：三要素，发送者、接收者、发送频道（Intent）；类型：有序（接收有序，有数据传送，可以拦截数据）、无序广播（相对）；注册方式：静态注册，持久监听，占用内存比较高生命周期跟随系统，动态注册（代码中），所有广播都可以动态注册，部分系统广播不能动态注册，临时监听，占用内存较少，生命周期随应用进行；

ContentProvide：不能存放数据，五种存放数据方式之一，特点为：①为数据的获取等操作添加一个统一的接口②可以实现跨应用访问数据；③可以实现Android中通讯录、消息、音频、视频等的访问或操作；通过ContentReceive进行数据的访问，可以对数据进行增删改查操作。

动画： IO流： 序列化： AlertDialog：

Set实现类： 手机电量检测：

自定义SurfaceView：

自定义View：三个构造方法的区别

Message:Handler.obtain/new/Message.obtain

HttpUriConnection访问网络

gride 异步任务 动画

抽象类和接口 反射 克隆 序列化 侧滑的实现 数据库 Socket:

Gson解析

异步任务和子线程区别 WebView 版本更新 照片的圆角化

Collection与Collections Sql语句

MVP框架与MVC： TCP与UDP的区别： 一键分享的流程： Http协议的理解： 不使用框架访问网络： List集合与set集合： 自定义View的流程： 线性布局的特点： ViewPager的原理： 服务的启动方式：

Activity的启动方式： Xml数据解析：

第四篇：Android 个人总结

Android 个人总结

通过本学期的的学习，我知道了android是由google开发的一款手机平台，android的基本架构是基于linux内核，由内核向外的反别为库和应用架构，然后就是我们手机上的可视化应用了，android是一个系统，但是并非是操作系统。

在开发之前，我们首先要搭建一个开发环境，用的是java编程的eclipse，我们从网上下载sdk包，里面包含了android开发常用的工具，android既是手机操作系统，也是跨平台(windows，mac，linux)的开发工具，虽然是使用linux为核心的平台，但是你可以在很多地方感觉到类似做网页开发的感觉。具有本身独特的进程管理方式，完整的上网功能，搭配了google地图，Gmail等服务，即使像我们这些尚未入门的开发者也能开发出自己理想的应用程序来。

刚开始的时候，得知android开发需要使用java语言心里了小小的畏惧，但随着学习的渐渐深入就会发现android平台只是使用了java的语法而已，所以，即使我们不具备java语言开发的基础，也可以放心地加入到android开发当中来。

第一节课，老师向我们详细介绍了开发界面右边窗口的内容，首先是src目录，里面包含了我们开发界面的java文件以及各种我们创建的类组成的开发包。然后是gen目录，里面涵盖的是系统的类文件(如R.java，Buidconfig.java)与android系统的依赖文件(Android Dependencies)。再下来是assets(用户资源文件)，里面文件的访问是通过文件路径的形式调用。Bin文件里面包括了res资源文件，android项目配置文件androidmanifest以及我们开发之后产生的后缀为.apk的应用程序文件。Res是系统资源目录，我们要用到得图片资源，颜色资源，字符串资源都在里面。一般的开发都要用到界面文件也包含在里面。

Eclipse具有史上超豪华的手机控件，包括常用的文本文件，文本框，按钮，进度条等，还有特殊形式的email，gmail文本框，在开发过程当中，很多控件都是以拖拉的形式拖拽到开发界面上，大大地减少了我们开发时候的工作量，在配置文件中，我们可以添加各种各样的系统动作，以及系统服务，还可以建立用户自己的文件库。

当我们开发完成的时候，就可以运行手机模拟器，在上面，我们可以像操作当今市场上最流行的android手机一样操作我们的模拟器，可视化的界面可以我们随心所欲地下载我们开发的应用程序到模拟器上，就可以实现步步跟进，想要修改哪里就一目了然了，模拟器上人性化的设计界面大大方便了用户与机器之间的交流。如果我们拥有一部android系统的手机的话，就可以把自己开发的应用程序下到手机上，看到自己的成果，顿生成就感，真的很有乐趣。也加大了我对学习android的信心。

总体来说，学习android就要不怕困难，迎难而上。Android不久可以满足自己的成就感，还可以在未来的生活中找到自己理想的工作。用别人准备好的各种类，包来开发出自己独特风格的应用程序，既省时又省力，何乐而不为呢。在这里，要感谢曾老师对我的栽培和关怀，他教给了我知识，使我在学习的时候少走了很多的弯路，也增加了我对未来工作的信心。

第五篇：Android 课程总结

一、Android开发环境的搭建。

1、Android SDK的安装；

2、ADT的安装和配置；

3、Android 模拟器的配置。

二、编写第一个Android程序───Hello World(1学时)

1、创建一个Android应用程序的步骤；

2、Android 应用程序目录结构；

3、AndroidManidest.xml文件的作用；

4、Android相关资源文件的作用。

三、Activity及Activity和Intent（2学时）

1、Activity的主要作用；

2、创建一个Activity的方法；

3、在AndroidManifest.xml文件中的注册应用Activity的方法；

4、在Activity中添加控件的方法；

5、多个Activity之间的切换；

6、Intent的基本作用；

7、在一个Activity中启动另一个Activity的方法；

8、使用Intent在Activity中传递数据的基本方法。

四、常见控件的使用方法(基础)

1、TextView的使用方法；

2、EditText的使用方法；

3、Button的使用方法；

4、Menu的使用方法。

五、Activity的生命周期（2学时）

1、Activity的七个周期:

① OnCreate();② OnDestroy();③ OnPause();④ OnRestart();⑤ OnResume();⑥ OnStart();⑦ OnStop();

2、Task的基本概念；

3、Activity和Task之间的关系；

4、对话框风格的Activity的使用方法。

六、Activity的布局（3学时）

1、LinearLayout的使用方法；

2、TableLayout的使用方法；

3、LinearLayout和TableLayout的嵌套使用；

4、RelativeLayout的使用方法（重点、难点）

七、常用控件是使用方法二（2学时）

1、RadioGroup和RadioButton的使用方法；

2、CheckBox的使用方法；

3、Toast的基本用法。

4、ProgressBar的使用方法；

5、ListView的用法。

八、Handler的使用方法（2学时）

1、Handler的基本概念；

2、Handler的基本用法；

3、使用Handler更新ProgressBar

4、Handler与线程；

5、Bundle的用法；

6、在新线程中处理消息的方法。

九、SQLite使用方法

1、SQLite介绍；

2、SQLiteOpenHeper使用方法；

3、使用adb访问SQLite

4、增、删、改、查。

十、Android文件下载

1、使用HTTP协议下载文件；

2、将下载的文件写入SDCARD。

十一、Content Provider初步（2学时）

1、Content Provider的基本概念；

2、Uri；

3、Content Provider的实现方法。

十二、XML文件的解析方法

1、什么是SAX；

2、SAX的基本原理；

3、SAX常用接口；

4、SAX解析。

十三、广播机制（2学时）

1、Android的广播机制（图鉴）；

2、BroadCastReceive的作用；

3、BroadCastReceive的编写方法；

4、BroadCastReceive的生命周期。

5、注册BroadCastReceive的方法；

6、Android内置BroadCastReceive Actions。

十四、WIFI网络的使用

1、什么是WIFI；

2、获取WIFI网卡的状态；

3、操作WIFI所需要的权限；

4、改变WIFI网卡的状态。

十五、Socket编程

1、什么是Socket；

2、Socket基本通信模型（见图）；

3、使用基于TCP协议的Socket；

4、使用基于UDP协议的Socket。

十六、Service

1、Service是什么；

2、Service不是什么；

3、Service的生命周期；

4、启动和停止Service；