android小结

一.

对与java读写文件的操作：

字节流：

//filename  可以是文件名，可以是文件路径

FileOutputStream outputStream=new FileOutputStream(filename);

//filename  可以是文件名，可以是文件路径

//append 是否追加

FileOutputStream outputStream=new FileOutputStream(filename，bool append);

outputStream.write(byte[]);

outputStream.close();

//filename 文件名或文件路径

FileInputStream inputStream=new FileInputStream(filename);

Byte[] buffer=new byte[1024];//缓存数组；

//inputStream.read(buffer);//返回值是int型；

读的时候要先把这些数据放入内存中或者是一个FileOutputStream流中

//FileOutputStream outputStream=new FileOutputStream(filename);

ByteArrayOutpouStream outputStream=new ByteArrayOutputStream();

Int len=0;

While((len=inputStream.read(buffer))!=-1)

{

outputStream.write(buffer,0,len);

}

二.

<?xml version=”1.0” encoding=”UTF-8”>

<persons>

<person id=”1”>

<name>wanghe</name>

<age>20</age>

</person>

</persons>

对于使用Pull解析器来解析XML

List<Person> persons=null;

Person person=null;

File file=new File(filename);

FileinputStream input=new FileInputStream(file);

XmlPullParser pullParser=XML.newPullParser();

pullParser.setInput(input,”UTF-8”);

Int event=pullParser.getEventType();

While(event!=XmlPullParser.END_DOCUMENT)

{

Switch(event)

{

Case XmlPullParser.START_DOCUMENT:

Persons=new ArrayList<Person>();

Break;

Case XmlPullParser.START_TAG

If(“person”.equal(pullParser.getName()))

{

Person=new Person();

String id=pullParser.getAttributeValue(0);

person.setId(id);

}

Else if(“name”.equal(pullParser.getName()))

{

String name=pullParser.nextText();

person.setName(name);

}

Else if(“age”.equal(pullParser.getName()))

{

String age=pullParser.nextText();

person.setAge(age);

}

Break;

Case XmlPullParser.END_TAG:

If(“person”.equal(pullParser.getName()))

{

Persons.add(person);

Person=null;

}

}

Event=pullParser.next();

}

Return persons;

对与保存一个XML

File file=new File(filename)

FileOutputStream out=new FileOutputStream(file);

XmlSerializer ser=XML.newXmlSerializer();

Ser.setOutput(out,”UTF-8”);

ser.startDocument(“UTF-8”,true);

ser.srartTag(null,”persons”)//第一个参数是namespace 第二个是节点名称

For(Person person:persons)

{

er.startTag(null, "person");

ser.attribute(null, "id", person.getId());

ser.startTag(null, "name");

ser.text(person.getName());

ser.endTag(null,"name");

ser.startTag(null, "age");

ser.text(person.getAge());

ser.endTag(null,"age");

ser.endTag(null, "person");

}

ser.endTag();

ser.endDocument();

Out.flush();

Out.close();

三.sharedPreferences

对于sharedPrefernces是对用户数据的一个自定义保存数据

比如每次等qq不用自己再输入帐号和密码而是从以前输入的数据存储后再调出

SharedPreferences share=context.getSharedPreferences("ifo",Context.MODE_PRIVATE);//参数一是对xml文件名的定义，参数二是对此文件的权限定义，context是上下文的意思，如getApplicationContext()等等；

Editor editor=share.edit();

editor.putString(“key”,”value”);

Editor.commit();

对于怎么取出数据就是；

SharedPreferences share=context.getSharedPreferences("ifo",Context.MODE_PRIVATE);

String value=share.getString(“key”,”defaultvalue”);//根据key来取值，那个defaultvalue是默认取到的值；

四．SQLiteDatabase

对与SQLite，他要实现SQLiteOpenHelper虚拟类

定义MySQLiteOpenHelper:

Class MySQLiteOpenHelper:SQLiteOpenHelper

{

//实现一个构造函数

Public MySQLiteOpenHelper(Context context)

{

//context 定义上下文

//databaseName 定义数据库名字

//CursorFactory 定义游标工厂,默认为null，使用系统的

//version 版本号，version>0 当version改变时会调用onUpgrade方法

Super(context,databaseNAME,CursoeFactory,version)

}

//实现两个方法

public void onCreate(SQLiteDatabase db) //在第一次调用是使用，可以加入多个execSQL()方法

{

// TODO Auto-generated method stub

db.execSQL("create table person (name text ,age text)");//定义一个表；

//为表初始化数据

//db.execSQL("insert into person(name,age)values (?,?)",new String[]{“wanghe”,”20”});

}

@Override

public void onUpgrade(SQLiteDatabase arg0, int arg1, int arg2)//当版本号改变是执行  {

// TODO Auto-generated method stub

//当version版本号改变时；

db.execSQL("alert table person add phone text");

}

}

定义SQLiteServer实现数据库方法

Class SQLiteServer

{

Private MySQLiteOpenHelper mySQL;

Public SQLiteServer (Context context)

{

mySQL=new MySQLiteOpenHelper(context);

}

//查询

Public Cursor select(String name)

{

SQLiteDatabase db=mySQL.getReadableDatabase();

Cursor cursor=db.rawQuery(“select * from person  where name=?”,new String[]{name});

Db.close();

Return cursor;

}

//实现分页效果，offset是开始，maxdata是查寻个数

Public Cursor selectLimit(int offset,int maxdata)

{

SQLiteDatabase db=mySQL.getReadableDatabase();

Cursor cursor=db.rawQuery(“select * from person limit ?,?” ,new String[]{String.valueof(offset),String.valueof(maxdata)});

Db.close();

Return cursor;

}

//插入

Public void insert(Person person)

{

SQLiteDatabase db=mySQL.getWriteableDatabase();

db.execSQL(“insert into person(name.age) values(?,?)”,new Object[]{person.getName(),person.getAge()});   }

//更新

Public void update(Person person)

{

SQLiteDatabase db=mySQL.getWriteableDatabase();

db.execSQL(“update person set age=? Where name=?”,new Object[]{person.getName(),person.getAge()});

Db.close();

}

//删除

Public void delete(String name)

{

SQLiteDatabase db=mySQL.getWriteableDatabase();

db.execSQL(“delete form person where name=?”,new Object[]{name});

db.close();
}

//获取查询的个数

Public long getCount()

{

SQLiteDatabase db=mySQL.getReadableDatabase();

Cursor cursor=db.rawQuery(“select count(*) from person “,null);

//由于只会出现一条记录

cursor.moveToFirst();

Long count=cursor.getLong(0);

Db.close();

Return count;

}

}

对伊Cursor这个类，里面的api

Cursor cursor；

如果查询结果是多个，则用cursro.moveToNext()这个方法

While(cursor.moveToNext())

{

//怎么获取记录,cursor.getColumnIndex(“name“)这个方法是获取name属性的下标

String name=cursor.getString(cursor.getColumnIndex(“name”));

}

对于SQLite的并发控制

Public void SqlCommit()

{

SQLiteDatabase db=mySQL.getWriteableDatabase();

db.beginTransaction();

Try

{

db.execSQL(“........”);

db.execSQL(“..........”);

db.setTransactionSuccessful();//如果不使用次api就只会回滚，不会提交

}

Finally{

db.endTransaction();

}

}

五.ListView及各Adapter

对与ListView的使用要用到各种构造器；

SimpleAdapter：

Class Person

{

Public String name;

Public String age;

}

List<Person>persons=new ArrayList<Person>();

List<HashMap<String,String>>listMap=new List<HashMap<String,String>>();

For(Person person:persons)

{

Map<String ,String>map=new HashMap<String,String>();

Map.put(“name”,person.name);

Map.put(“age”,person.age);

listMap.add(map);

}

SimpleAdapter adapter=new SimpleAdapter(Context context,listMap,R.layout.xml,new String[]{“name”,”age”},new int[]{R.id.txtname,R.is.txtage});

list.setAdapter(adapter);//第一个参宿是上下文context，第二个参数是List<HashMap<String,String>>

第三个参数是，布局layout，第四个是HashMap里的key字符串数组，第五个是布局里的R.id数组；

对于怎么取到这样构造的形式的数据

OnItemClick(AdapterView<?> parent, View view, int position,long id)

{

//因为存入的是HashMap,则在取时也应是hashmap

HashMap<String,String>map=HasnMap<String,String>parent.getItemPosition(position);

String name=map.get(“name”);

String age=map.get(“age”);

}

第二种构造器就是SimpleCursorAdapter，此方法感觉就是重在去SQLite里的Cursor

因为在SQLite里有Cursor cursor=db.rawQuery(“”,null);

SimpleCursorAdapter adapter=new SimpleCursorAdapter(Context,R.layout.xml,cursor,new String[]{“name”,”age”},new int[]{R.id.txtname,R.id.txtage});

list.setAdapter(adapter);

对于这种的取数据，当然要用到Cursor

OnItemClick(AdapterView<?> parent, View view, int position,long id)

{

Cursorcursor=(Cursor)parent.getItemPosition(position);

String name=cursor.getString(cursor.getColumnIndex(“name”));

String age=cursor.getString(cursor.getColumnIndex(“n\age”));

}

第三种就是自己写构造器，继承BaseAdapter

Class PersonAdapter implements BaseAdapter

{

Private List<Person> persons;//传入的List

Private int Resouce;//传入自定义布局

Private LayoutInflater inflater;//构造一个View

public PersonAdapter(Context context,List<Person> persons,int resource)

{

this.persons=persons;

this.Resource=resource;

inflater=(LayoutInflater)ontext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

}

@Override

public int getCount() {

// TODO Auto-generated method stub

return persons.size();

}

@Override

public Object getItem(int arg0) {

// TODO Auto-generated method stub

return persons.get(arg0);

}

@Override

public long getItemId(int arg0) {

// TODO Auto-generated method stub

return arg0;

}

对伊getView这个方法，有两种，一个效率高，一个效率低

@Override

public View getView(int position, View view, ViewGroup arg2) {

// TODO Auto-generated method stub

TextView txtname=null;

TextView txtage=null;

If(view==null)

{

View=inflater.inflate(this.Resource,null);

}

Txtname=(TextView)view.findViewById(R.id.txtname);

Txtage=(TextView)view.findViewById(R.id.txtage);

Person person=persons.get(position);

txtname.setText(person.name);

txtage.setText(person.age);

Return view;

}

//第二种getView

@Override

public View getView(int position, View view, ViewGroup arg2) {

// TODO Auto-generated method stub

TextView txtname=null;

TextView txtage=null;

If(view==null)

{

View=inflater.inflater(Resouce,null);

CacheView cache=new CacheView();

Txtname=(TextView)view.findViewById(R.id.txtname);

Txtage=(TextView)view.findViewById(R.id.txtage);

Cache.txtname=txtname;

Cache.txtage=txtage;

view.setTag(cache);

}

Else

{

CacheView cache=(CacheView)view.getTag();

Txtname=cache.txtname;

Txtage=cache.txtage;

}

Person person=persons.get(position);

txtname.setText(person.name);

txtage.setText(perosn.age);

Return view;

}

Private final class CacheView

{

Public TextView txtname;

Public TextView txtage;

}

}

对于这样的取就简单了

OnItemClick(AdapterView<?> parent, View view, int position,long id)

{

Person Person=(Person) parent.getItemAtPosition(position);

String name=person.name;

String age=person.age;

｝

六.ContentProvider

为别的应用提供数据源

继承ContentProvider类

public class TestProvider extends ContentProvider {

//定义一个全局的变量UriMatcher

private UriMatcher matcher=new UriMatcher(UriMatcher.NO_MATCH);

//定义三个标识变量

private final static int PERSON =1;

private final static int STUDENT=2;

private final static int PERSONID=0;

//为了取得数据库所以调用自己定义的SQLiteOpenHelper

private OPSQLHelper SQLHelper=null；

//相当与构造函数

@Override

public boolean onCreate() {

// TODO Auto-generated method stub

SQLHelper=new OPSQLHelper(getContext());

matcher.addURI("com.example.dbprovider.prodiver", "person", PERSON);//添加person的匹配，如果匹配则返回PERSON

matcher.addURI("com.example.dbprovider.prodiver", "student", STUDENT);//添加student的匹配，如果匹配则返回STUDENT

matcher.addURI("com.example.dbprovider.prodiver", "person/#", PERSONID);//添加person/id的匹配，如果匹配则返回PERSONID

return true;

}

@Override

public Cursor query(Uri arg0, String[] arg1, String arg2, String[] arg3,

String arg4) {

// TODO Auto-generated method stub

SQLiteDatabase db=SQLHelper.getReadableDatabase();

//可以通过判断传入的Uri来确定去操作哪个表

switch(matcher.match(arg0))

{

case PERSONID:

long id=ContentUris.parseId(arg0);//这个方法可以解析出id的值;

if(arg2==null)

{

arg2="id="+id;

}

else

{

arg2+="and id="+id;

}

case PERSON:

return  db.query("person", arg1, arg2, arg3, null, null, arg4);

case STUDENT:

default:

throw Exception ;

break;

}

return null;

}

@Override

public int delete(Uri arg0, String arg1, String[] arg2) {

// TODO Auto-generated method stub

return 0;

}

@Override

public String getType(Uri arg0) {

// TODO Auto-generated method stub

return null;

}

@Override

public Uri insert(Uri arg0, ContentValues arg1) {

// TODO Auto-generated method stub

return null;

}

@Override

public int update(Uri arg0, ContentValues arg1, String arg2, String[] arg3) {

// TODO Auto-generated method stub

return 0;

}

}

怎么调用Provider提供的方法：

Uri uri=Uri.parse(“”);

ContentReslover reslover=this.getContentReslover();

Reslover.query(uri,,,,,);

Reslover.insert(uri,,);

......

对于ContentProvider要进行监听事件，包括两方面，一个是注册一个监听观察者，一个是要有一个发布者，当观察者观察到发布者发布改变消息后，就做出反应；

下面一个例子，当插入一个数据后，然后发布者发布一个消息，观察者收到做出反应

发布者：

getContext().getContentResover().notifyChange(Uri,ContentObserver);发布一条改变消息

观察者：

this.getContentResolver().registerContentObserver(Uri, true, new ContentObserver1());

Class ContentObserver extends ContentObserver

{

public ContentObserver1() {

super(new Handler());

// TODO Auto-generated constructor stub

}

@Override

public void onChange(boolean selfChange) {

// TODO Auto-generated method stub

//Do something

}

}

七.网络服务

获取网页内容：

URL url=new URL(“http://www.baidu.com”);

HttpURLConnection conn=(HttpURLConnection)url.openConnection();

conn.setConnectTimeout(5000);

conn.setRequestMethod("GET");

if(conn.getResponseCode()==200)

{

InputStream is=conn.getInputStream();

ByteArrayOutputStream os=new ByteArrayOutputStream();

byte[] buff=new byte[1024];

Int len=0;

While((len=is.read(buff))!=-1)

{

Os.write(buff,0,len);

}

String str=os.toString();

Is.close();

Os.close();

获取网页图片

URL url;

try {

url = new URL(urlPath);

HttpURLConnection conn=(HttpURLConnection)url.openConnection();

conn.setConnectTimeout(5000);

conn.setRequestMethod("GET");

if(conn.getResponseCode()==200)

{

InputStream is=conn.getInputStream();

Bitmap bit=BitmapFactory.decodeStream(is);

img.setImageBitmap(bit);

}

Intent

对与intent，常用来激活下一个activity，

常用的方法就是：

Intent intent=new Intent(this,newActivity.class);

对于传数据，有以下几种方式：

第一种：

放数据：

Intent intent=new Intent(MainActivity.this,NextActivity.class);

intent.putExtra("name", "王贺");

intent.putExtra("age", 21);

startActivity(intent);

取数据：

Intent intent=getIntent();

String name=intent.getStringExtra("name");

int age=intent.getIntExtra("age",0);

Toast.makeText(getApplicationContext(), name+"   "+age, 1).show();

第二种：

放数据：

Intent intent=new Intent(MainActivity.this,NextActivity.class);

Bundle bun=new Bundle();

bun.putString("name", "王贺");

bun.putInt("age", 21);

intent.putExtras(bun);

startActivity(intent);

取数据：

Intent intent=getIntent();

Bundle bun=intent.getExtras();

String name=bun.getString("name");

int age=bun.getInt("age");

Toast.makeText(getApplicationContext(), name+"   "+age, 1).show();

第三种：传递对象：

要对对象类进行封装：

public class Person implements Parcelable{

private int id ;

private String name;

private int age;

public int describeContents() {

// TODO Auto-generated method stub

return 0;

}

//把数据写入到Parcel对象

public void writeToParcel(Parcel dest, int flags) {

// TODO Auto-generated method stub

dest.writeInt(id);

dest.writeString(name);

dest.writeInt(age);

}

public static final Parcelable.Creator<Person> CREATOR

= new Parcelable.Creator<Person>() {

//从Parcel对象里面读取数据

public Person createFromParcel(Parcel in) {

return new Person(in);

}

public Person[] newArray(int size) {

return new Person[size];

}

};

public Person(Parcel in) {

// TODO Auto-generated constructor stub

id = in.readInt();

name = in.readString();

age = in.readInt();

}

public Person(int id, String name, int age) {

super();

this.id = id;

this.name = name;

this.age = age;

}

@Override

public String toString() {

return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";

}

}

放数据：

Intent intent=new Intent(MainActivity.this,NextActivity.class);

Person person=new Person(1,"wanghe",20);

intent.putExtra("person", person);

startActivity(intent);

取数据：

Intent intent=getIntent();

Person person=intent.getParcelableExtra("person");

关于Intent之startActivityForResult

代码：

Intent intent=new Intent(this,NextActivity.class);

//参数：意图，请求码

startActivityForResult(intent,100);

要重写protected void onActivityResult(int requestCode, int resultCode, Intent data) {

// TODO Auto-generated method stub

super.onActivityResult(requestCode, resultCode, data);

if(requestCode==100)

If(data!=null)

{

Toast.makeText(getApplicationContext(),   data.getStringExtra("name"), 1).show();

}

}

NextActivity:

Intent intent=new Intent();

intent.putExtra("name", name);

//参数 结果码，意图

setResult(200, intent);

finish();

线程

当要访问的数据使反应的时间特别长，如获取网页数据，传输的文件等，就要用到线程

线程就要用到Handler这个中间类来链接主进程和线程的联系：

Handler handler=new Handler(){

@Override

public void handleMessage(Message msg) {

// TODO Auto-generated method stub

super.handleMessage(msg);

Switch(msg.what)

{

Case 1:

Msg.obj//获取消息内容，

//dosomething

Case 2:

}

}

};

New Thread(){

Public void run(){

Message msg=new Message();

Msg.what=1;//因为可能有多个消息，所以msg.what标识一唯一消息标识

Msg.obj=””;//msg.obj发送消息的内容

handler.sendMessage(msg);//发送信息

}

}.start();

Dialog

简单对话框：

AlertDialog.Builder builder=new AlertDialog.Builder(this);

builder.setTitle("简单对话框");

builder.setMessage("确定吗");

builder.setPositiveButton("确定", new DialogInterface.OnClickListener() {

@Override

public void onClick(DialogInterface arg0, int arg1) {

// TODO Auto-generated method stub

}

});

builder.setNegativeButton("取消", new DialogInterface.OnClickListener() {

@Override

public void onClick(DialogInterface arg0, int arg1) {

// TODO Auto-generated method stub

}

});

AlertDialog dialog=builder.create();

dialog.show();

单选对话框：

final String[] items=new String[]{"JAVA","PHP","ASP"};

AlertDialog.Builder builder=new AlertDialog.Builder(this);

builder.setTitle("单选对话框");

builder.setItems(items, new DialogInterface.OnClickListener() {

@Override

public void onClick(DialogInterface arg0, int arg1) {

// TODO Auto-generated method stub

Toast.makeText(getApplicationContext(), items[arg1], 0).show();

}

});

AlertDialog dialog=builder.create();

dialog.show();

多选对话框：

final String[] items = new String[]{"java","C#","php"};

final boolean[] checkedItems=new boolean[]{false,false,false};

AlertDialog.Builder builder=new AlertDialog.Builder(this);

builder.setTitle("选择");

builder.setMultiChoiceItems(items, checkedItems, new DialogInterface.OnMultiChoiceClickListener() {

@Override

public void onClick(DialogInterface arg0, int arg1, boolean arg2) {

// TODO Auto-generated method stub

}

});

builder.setPositiveButton("确定",new DialogInterface.OnClickListener() {

@Override

public void onClick(DialogInterface arg0, int arg1) {

// TODO Auto-generated method stub

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

{

if(checkedItems[i]==true)

{

str+=items[i];

}

}

Toast.makeText(getApplicationContext(), str, 1).show();

}

});

AlertDialog dialog=builder.create();

dialog.show();

自定义对话框：

LayoutInflater infalter = LayoutInflater.from(this);;

View view=infalter.inflate(R.layout.item,null);

AlertDialog.Builder builder=new AlertDialog.Builder(this);

builder.setTitle("hh");

builder.setView(view);

AlertDialog dialog=builder.create();

dialog.show();

Broadcast

对于BroadcastReceiver

对于拦截短信：

Xml配置

<uses-permission android:name="android.permission.RECEIVE_SMS"/>

<receiver android:name=".SmsBroadCast">

<intent-filter android:priority="1000">

<action android:name="android.provider.Telephony.SMS_RECEIVED"/>

</intent-filter>

</receiver>

代码：

public class SmsBroadCast extends BroadcastReceiver {

@Override

public void onReceive(Context arg0, Intent arg1) {

// TODO Auto-generated method stub

Log.i("i", "拦截到短信");

Bundle bundle=arg1.getExtras();

Object[] objects=(Object[]) bundle.get("pdus");//接收一个key=pdus

for(Object object:objects)

{

SmsMessage message=SmsMessage.createFromPdu((byte[]) object);

String address=message.getDisplayOriginatingAddress();

String body=message.getDisplayMessageBody();

long date=message.getTimestampMillis();

SimpleDateFormat formater=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

String formatDate=formater.format(date);

Log.i("i", address+" "+body+" "+formatDate);

abortBroadcast();

}

}

}

外拨电话：

Xml配置：

<uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS"/>

<receiver android:name=".PhoneBroadCast">

<intent-filter >

<action android:name="android.intent.action.NEW_OUTGOING_CALL"/>

</intent-filter>

</receiver>

代码：

public class PhoneBroadCast extends BroadcastReceiver {

@Override

public void onReceive(Context arg0, Intent arg1) {

// TODO Auto-generated method stub

String num=getResultData();//得到号码

setResultData("");//设置号码

Log.i("i", num);

}

}

自定义广播

自定义发送：

Intent intent=new Intent();

intent.setAction("cn.mydefine.broadcase");

intent.putExtra("msg", txt.getText().toString());

sendBroadcast(intent);

Xml配置：

<receiver android:name=".CustomRec">

<intent-filter>

<action android:name="cn.mydefine.broadcase"/>

</intent-filter>

</receiver>

接收广播：

public class CustomRec extends BroadcastReceiver {

@Override

public void onReceive(Context arg0, Intent arg1) {

// TODO Auto-generated method stub

String msg=arg1.getStringExtra("msg");

Log.i("msg", msg);

}

}

服务 Service

服务需要手动打开：

例：

打开服务：

Intent intent=new Intent(this,PhoneService.class);

startService(intent);

服务代码：监听电话状态：

public class PhoneService extends Service {

private TelephonyManager tm;

@Override

public void onCreate() {

// TODO Auto-generated method stub

super.onCreate();

tm=(TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);

tm.listen(new PhoneStateListener1(), PhoneStateListener.LISTEN_CALL_STATE);

}

private final class PhoneStateListener1 extends PhoneStateListener

{

@Override

public void onCallStateChanged(int state, String incomingNumber) {

// TODO Auto-generated method stub

super.onCallStateChanged(state, incomingNumber);

Log.i("电话号码：", incomingNumber+"");

switch(state)

{

case TelephonyManager.CALL_STATE_IDLE:

Log.i("i：", "无状态");

break;

case TelephonyManager.CALL_STATE_OFFHOOK:

Log.i("i：", "接听状态");

break;

case TelephonyManager.CALL_STATE_RINGING:

Log.i("i：", "响铃状态");

break;

}

}

}

@Override

public IBinder onBind(Intent arg0) {

// TODO Auto-generated method stub

return null;

}

}

Xml配置：

<service android:name=".PhoneService"></service>

访问本地自定义服务

<service android:name=".StudentService"></service>

1.绑定服务：Intent intent=new Intent(this,StudentService.class);

//bindService三个参数，意图，服务连接ServiceConnection，还有自动链接字段

bindService(intent, conn, Context.BIND_AUTO_CREATE);

2.继承ServiceConnection借口，重写ServiceConnection

private class MyServiceConnection implements ServiceConnection

{

@Override

public void onServiceConnected(ComponentName arg0, IBinder arg1) {

// TODO Auto-generated method stub

//返回值是IBinder接口，所以转换为iStudentService接口来查询

iStudentService=(IStudentService) arg1;

}

@Override

public void onServiceDisconnected(ComponentName arg0) {

// TODO Auto-generated method stub

conn=null;

iStudentService=null;

}

}

@Override

//释放链接

protected void onDestroy() {

// TODO Auto-generated method stub

super.onDestroy();

unbindService(conn);

}

3.定义接口：

public interface IStudentService {

public Student getStudent(int no);

}

4.写服务：

public class StudentService extends Service {

private final Student[] students=new Student[]{new Student(1,"王贺",20),new Student(2,"黎明",22),new Student(3,"线路",23)};

private QueryStudent  queryStudent=null;

@Override

//返回值是IBinder，所以QueryStudent继承Binder和IstudentService

public IBinder onBind(Intent arg0) {

// TODO Auto-generated method stub

queryStudent=new QueryStudent();

return queryStudent;

}

public final class QueryStudent extends Binder implements IStudentService

{

@Override

public Student getStudent(int no) {

// TODO Auto-generated method stub

return query(no);

}

public Student query(int no)

{

return students[no-1];

}

}

}

两个应用之间的服务通信；要用到dial文件；在传输对象时，对象要继承Parcelable

服务端代码：

Student.java

package domin;

import android.os.Parcel;

import android.os.Parcelable;

public class Student implements Parcelable {

private int no;

private String name;

private int age;

@Override

public int describeContents() {

// TODO Auto-generated method stub

return 0;

}

@Override

public void writeToParcel(Parcel arg0, int arg1) {

// TODO Auto-generated method stub

arg0.writeInt(no);

arg0.writeString(name);

arg0.writeInt(age);

}

public static final Parcelable.Creator<Student> CREATOR

= new Parcelable.Creator<Student>() {

//从Parcel对象里面读取数据

public Student createFromParcel(Parcel in) {

return new Student(in);

}

public Student[] newArray(int size) {

return new Student[size];

}

};

public Student(Parcel in) {

// TODO Auto-generated constructor stub

no= in.readInt();

name = in.readString();

age = in.readInt();

}

public Student(int no,String name,int age)

{

this.no=no;

this.name=name;

this.age=age;

}

@Override

public String toString() {

// TODO Auto-generated method stub

return no+"   "+name+"    "+age;

}

}

新建一个dial文件来标明它：

Student.dial

package domin;//标明包名

parcelable Student;//标明类名，parcelable要小写

接口：IStudentService.java

package inter;

import domin.Student;

interface IStudentService {

Student queryStudent(int no);

}

建立这个接口后要改为dial文件

然后系统会为此接口改写代码，里面有一个Stub类，这个类继承Binder和IStudentService接口

然后是student服务

StudentService.java

package serve;

import domin.Student;

import inter.IStudentService.Stub;

import android.app.Service;

import android.content.Intent;

import android.os.IBinder;

import android.os.RemoteException;

public class StudentService extends Service{

private MyStudentService binder=new MyStudentService();

private Student[] students=new Student[]{new Student(1,"王贺",21),new Student(2,"黎明",22),new Student(3,"线路",23)};

@Override

public IBinder onBind(Intent arg0) {

// TODO Auto-generated method stub

return binder;

}

private final class MyStudentService extends Stub//由于系统对代码的改写，所以只需要继承Stub类就是对Binder和IStudentService接口的继承

{

@Override

public Student queryStudent(int no) throws RemoteException {

// TODO Auto-generated method stub

return query(no-1);

}

public Student query(int no)

{

return students[no-1];

}

}

}

由于是两个应用所以要对次服务注册下，

Xml配置：

<service android:name="serve.StudentService">

<intent-filter>

<action android:name="com.example.MyServer"/>

</intent-filter>

</service>

客户端代码，要把服务器端的除了StudentService类外，把别的类和包复制到客户端的src里面以保持一致

package com.example.client;

import domin.Student;

import inter.IStudentService;

import inter.IStudentService.Stub;

import android.os.Bundle;

import android.os.IBinder;

import android.os.RemoteException;

import android.app.Activity;

import android.content.ComponentName;

import android.content.Context;

import android.content.Intent;

import android.content.ServiceConnection;

import android.view.Menu;

import android.view.View;

import android.widget.EditText;

import android.widget.TextView;

public class MainActivity extends Activity {

private EditText txt=null;

private TextView msg=null;

private IStudentService iStudentService;

private MyServiceConnection conn;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

txt=(EditText)findViewById(R.id.txt);

msg=(TextView)findViewById(R.id.msg);

conn=new MyServiceConnection();

Intent intent=new Intent();

intent.setAction("com.example.MyServer");

bindService(intent,conn,Context.BIND_AUTO_CREATE);

}

private final class MyServiceConnection implements ServiceConnection

{

@Override

public void onServiceConnected(ComponentName arg0, IBinder arg1) {

// TODO Auto-generated method stub

iStudentService=Stub.asInterface(arg1);

}

@Override

public void onServiceDisconnected(ComponentName arg0) {

// TODO Auto-generated method stub

conn=null;

iStudentService=null;

}

}

public void query(View v)

{

try {

Student student=iStudentService.queryStudent(Integer.valueOf(txt.getText().toString()));

msg.setText(student.toString());

} catch (NumberFormatException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (RemoteException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

@Override

protected void onDestroy() {

// TODO Auto-generated method stub

super.onDestroy();

unbindService(conn);

}

@Override

public boolean onCreateOptionsMenu(Menu menu) {

// Inflate the menu; this adds items to the action bar if it is present.

getMenuInflater().inflate(R.menu.main, menu);

return true;

}

}

HTTP

/**

* @author Dylan

* 本类封装了Android中向web服务器提交数据的两种方式四种方法

*/

public class SubmitDataByHttpClientAndOrdinaryWay {

/**

* 使用get请求以普通方式提交数据

* @param map 传递进来的数据，以map的形式进行了封装

* @param path 要求服务器servlet的地址

* @return 返回的boolean类型的参数

* @throws Exception

*/

public Boolean submitDataByDoGet(Map<String, String> map, String path) throws Exception {

// 拼凑出请求地址

StringBuilder sb = new StringBuilder(path);

sb.append("?");

for (Map.Entry<String, String> entry : map.entrySet()) {

sb.append(entry.getKey()).append("=").append(entry.getValue());

sb.append("&");

}

sb.deleteCharAt(sb.length() - 1);

String str = sb.toString();

System.out.println(str);

URL Url = new URL(str);

HttpURLConnection HttpConn = (HttpURLConnection) Url.openConnection();

HttpConn.setRequestMethod("GET");

HttpConn.setReadTimeout(5000);

// GET方式的请求不用设置什么DoOutPut()之类的吗？

if (HttpConn.getResponseCode() == HttpURLConnection.HTTP_OK) {

return true;

}

return false;

}

/**

* 普通方式的DoPost请求提交数据

* @param map 传递进来的数据，以map的形式进行了封装

* @param path 要求服务器servlet的地址

* @return 返回的boolean类型的参数

* @throws Exception

*/

public Boolean submitDataByDoPost(Map<String, String> map, String path) throws Exception {

// 注意Post地址中是不带参数的，所以newURL的时候要注意不能加上后面的参数

URL Url = new URL(path);

// Post方式提交的时候参数和URL是分开提交的，参数形式是这样子的：name=y&age=6

StringBuilder sb = new StringBuilder();

// sb.append("?");

for (Map.Entry<String, String> entry : map.entrySet()) {

sb.append(entry.getKey()).append("=").append(entry.getValue());

sb.append("&");

}

sb.deleteCharAt(sb.length() - 1);

String str = sb.toString();

HttpURLConnection HttpConn = (HttpURLConnection) Url.openConnection();

HttpConn.setRequestMethod("POST");

HttpConn.setReadTimeout(5000);

HttpConn.setDoOutput(true);

HttpConn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

HttpConn.setRequestProperty("Content-Length", String.valueOf(str.getBytes().length));

OutputStream os = HttpConn.getOutputStream();

os.write(str.getBytes());

if (HttpConn.getResponseCode() == HttpURLConnection.HTTP_OK) {

return true;

}

return false;

}

/**

* 以HttpClient的DoGet方式向服务器发送请数据

* @param map 传递进来的数据，以map的形式进行了封装

* @param path 要求服务器servlet的地址

* @return 返回的boolean类型的参数

* @throws Exception

*/

public Boolean submitDataByHttpClientDoGet(Map<String, String> map, String path) throws Exception {

HttpClient hc = new DefaultHttpClient();

// 请求路径

StringBuilder sb = new StringBuilder(path);

sb.append("?");

for (Map.Entry<String, String> entry : map.entrySet()) {

sb.append(entry.getKey()).append("=").append(entry.getValue());

sb.append("&");

}

sb.deleteCharAt(sb.length() - 1);

String str = sb.toString();

System.out.println(str);

HttpGet request = new HttpGet(sb.toString());

HttpResponse response = hc.execute(request);

if (response.getStatusLine().getStatusCode() == HttpURLConnection.HTTP_OK) {

return true;

}

return false;

}

/**

* 以HttpClient的DoPost方式提交数据到服务器

* @param map 传递进来的数据，以map的形式进行了封装

* @param path 要求服务器servlet的地址

* @return 返回的boolean类型的参数

* @throws Exception

*/

public Boolean submintDataByHttpClientDoPost(Map<String, String> map, String path) throws Exception {

// 1. 获得一个相当于浏览器对象HttpClient，使用这个接口的实现类来创建对象，DefaultHttpClient

HttpClient hc = new DefaultHttpClient();

// DoPost方式请求的时候设置请求，关键是路径

HttpPost request = new HttpPost(path);

// 2. 为请求设置请求参数，也即是将要上传到web服务器上的参数

List<NameValuePair> parameters = new ArrayList<NameValuePair>();

for (Map.Entry<String, String> entry : map.entrySet()) {

NameValuePair nameValuePairs = new BasicNameValuePair(entry.getKey(), entry.getValue());

parameters.add(nameValuePairs);

}

// 请求实体HttpEntity也是一个接口，我们用它的实现类UrlEncodedFormEntity来创建对象，注意后面一个String类型的参数是用来指定编码的

HttpEntity entity = new UrlEncodedFormEntity(parameters, "UTF-8");

request.setEntity(entity);

// 3. 执行请求

HttpResponse response = hc.execute(request);

// 4. 通过返回码来判断请求成功与否

if (response.getStatusLine().getStatusCode() == HttpURLConnection.HTTP_OK) {

return true;

}

return false;

}

}