博客园_等待

Android系列之MediaPlayer 多媒体播放器

2010-11-14T05:01:00Z

MediaPlayer 可以播放音频和视频，另外也可以通过VideoView来播放视频，虽然VideoView比MediaPlayer简单易用，但定制性不如用 MediaPlayer，要视情况选择了。MediaPlayer播放音频比较简单，但是要播放视频就需要SurfaceView。 SurfaceView比普通的自定义View更有绘图上的优势，它支持完全的OpenGL ES库。

先看看效果吧！

1 <?xml version="1.0" encoding="utf-8"?>
2 <LinearLayout android:id="@+id/LinearLayout01"
3 android:layout_width="fill_parent" android:layout_height="fill_parent"
4 xmlns:android="http://schemas.android.com/apk/res/android"
5 android:orientation="vertical">
6 <SeekBar android:id="@+id/SeekBar01" android:layout_height="wrap_content"
7 android:layout_width="fill_parent"></SeekBar>
8 <LinearLayout android:id="@+id/LinearLayout02"
9 android:layout_width="wrap_content" android:layout_height="wrap_content">
10 <Button android:id="@+id/Button01" android:layout_width="wrap_content"
11 android:layout_height="wrap_content" android:text="播放音频"></Button>
12 <Button android:id="@+id/Button02" android:layout_width="wrap_content"
13 android:layout_height="wrap_content" android:text="停止播放"></Button>
14 </LinearLayout>
15 <SeekBar android:id="@+id/SeekBar02" android:layout_height="wrap_content"
16 android:layout_width="fill_parent"></SeekBar>
17
18 <SurfaceView android:id="@+id/SurfaceView01"
19 android:layout_width="fill_parent" android:layout_height="250px"></SurfaceView>
20 <LinearLayout android:id="@+id/LinearLayout02"
21 android:layout_width="wrap_content" android:layout_height="wrap_content">
22 <Button android:layout_width="wrap_content"
23 android:layout_height="wrap_content" android:id="@+id/Button03"
24 android:text="播放视频"></Button>
25 <Button android:layout_width="wrap_content"
26 android:layout_height="wrap_content" android:text="停止播放" android:id="@+id/Button04"></Button>
27 </LinearLayout>
28 </LinearLayout>
29

1 package com.testMedia;
2
3 import java.io.IOException;
4 import java.util.Timer;
5 import java.util.TimerTask;
6 import android.app.Activity;
7 import android.media.AudioManager;
8 import android.media.MediaPlayer;
9 import android.os.Bundle;
10 import android.view.SurfaceHolder;
11 import android.view.SurfaceView;
12 import android.view.View;
13 import android.widget.Button;
14 import android.widget.SeekBar;
15 import android.widget.Toast;
16
17
18 public class TestMedia extends Activity {
19 /** Called when the activity is first created. */
20
21 private SeekBar skb_audio=null;
22 private Button btn_start_audio = null;
23 private Button btn_stop_audio = null;
24
25 private SeekBar skb_video=null;
26 private Button btn_start_video = null;
27 private Button btn_stop_video = null;
28 private SurfaceView surfaceView;
29 private SurfaceHolder surfaceHolder;
30
31 private MediaPlayer m = null;
32 private Timer mTimer;
33 private TimerTask mTimerTask;
34
35 private boolean isChanging=false;//互斥变量，防止定时器与SeekBar拖动时进度冲突
36 @Override
37 public void onCreate(Bundle savedInstanceState) {
38 super.onCreate(savedInstanceState);
39 setContentView(R.layout.main);
40
41 //----------Media控件设置---------//
42 m=new MediaPlayer();
43
44 //播放结束之后弹出提示
45 m.setOnCompletionListener(new MediaPlayer.OnCompletionListener(){
46 @Override
47 public void onCompletion(MediaPlayer arg0) {
48 Toast.makeText(testMedia.this, "结束", 1000).show();
49 m.release();
50 }
51 });
52
53 //----------定时器记录播放进度---------//
54 mTimer = new Timer();
55 mTimerTask = new TimerTask() {
56 @Override
57 public void run() {
58 if(isChanging==true)
59 return;
60
61 if(m.getVideoHeight()==0)
62 skb_audio.setProgress(m.getCurrentPosition());
63 else
64 skb_video.setProgress(m.getCurrentPosition());
65 }
66 };
67
68 mTimer.schedule(mTimerTask, 0, 10);
69
70 btn_start_audio = (Button) this.findViewById(R.id.Button01);
71 btn_stop_audio = (Button) this.findViewById(R.id.Button02);
72 btn_start_audio.setOnClickListener(new ClickEvent());
73 btn_stop_audio.setOnClickListener(new ClickEvent());
74 skb_audio=(SeekBar)this.findViewById(R.id.SeekBar01);
75 skb_audio.setOnSeekBarChangeListener(new SeekBarChangeEvent());
76
77 btn_start_video = (Button) this.findViewById(R.id.Button03);
78 btn_stop_video = (Button) this.findViewById(R.id.Button04);
79 btn_start_video.setOnClickListener(new ClickEvent());
80 btn_stop_video.setOnClickListener(new ClickEvent());
81 skb_video=(SeekBar)this.findViewById(R.id.SeekBar02);
82 skb_video.setOnSeekBarChangeListener(new SeekBarChangeEvent());
83 surfaceView = (SurfaceView) findViewById(R.id.SurfaceView01);
84 surfaceHolder = surfaceView.getHolder();
85 surfaceHolder.setFixedSize(100, 100);
86 surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
87 }
88
89 /**
90 * 按键事件处理
91 */
92 class ClickEvent implements View.OnClickListener{
93 @Override
94 public void onClick(View v) {
95 if(v==btn_start_audio)
96 {
97 m.reset();//恢复到未初始化的状态
98 m=MediaPlayer.create(testMedia.this, R.raw.big);//读取音频
99 skb_audio.setMax(m.getDuration());//设置SeekBar的长度
100 try {
101 m.prepare(); //准备
102 } catch (IllegalStateException e) {
103 // TODO Auto-generated catch block
104 e.printStackTrace();
105 } catch (IOException e) {
106 // TODO Auto-generated catch block
107 e.printStackTrace();
108 }
109 m.start(); //播放
110 }
111 else if(v==btn_stop_audio || v==btn_stop_video)
112 {
113 m.stop();
114 }
115 else if(v==btn_start_video)
116 {
117 m.reset();//恢复到未初始化的状态
118 m=MediaPlayer.create(testMedia.this, R.raw.test);//读取视频
119 skb_video.setMax(m.getDuration());//设置SeekBar的长度
120 m.setAudioStreamType(AudioManager.STREAM_MUSIC);
121 m.setDisplay(surfaceHolder);//设置屏幕
122
123 try {
124 m.prepare();
125
126 } catch (IllegalArgumentException e) {
127 // TODO Auto-generated catch block
128 e.printStackTrace();
129 } catch (IllegalStateException e) {
130 // TODO Auto-generated catch block
131 e.printStackTrace();
132 } catch (IOException e) {
133 // TODO Auto-generated catch block
134 e.printStackTrace();
135 }
136 m.start();
137 }
138 }
139 }
140
141 /**
142 * SeekBar进度改变事件
143 */
144 class SeekBarChangeEvent implements SeekBar.OnSeekBarChangeListener{
145
146 @Override
147 public void onProgressChanged(SeekBar seekBar, int progress,
148 boolean fromUser) {
149 // TODO Auto-generated method stub
150
151 }
152
153 @Override
154 public void onStartTrackingTouch(SeekBar seekBar) {
155 isChanging=true;
156 }
157
158 @Override
159 public void onStopTrackingTouch(SeekBar seekBar) {
160 m.seekTo(seekBar.getProgress());
161 isChanging=false;
162 }
163
164 }
165
166 }
167

本文链接

Android系列之Intent传递对象的两种方法

2010-11-14T04:28:00Z

在Android中intent传递对象主要有2种方式分别是，Bundle.putSerializable(Key,Object)和Bundle.putParcelable(Key, Object);当然这些Object是有一定的条件的，前者是实现了Serializable接口，而后者是实现了Parcelable接口，以下是我为大家做的一个实例

首先我们建立一个工程项目命名为：ObjectTestDemo

然后我们再修改main.xml布局文件，主要增加2个按钮

1 view plaincopy to clipboardprint?
2
3 < ?xml version="1.0" encoding="utf-8"?>
4
5 < LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
6
7 android:orientation="vertical"
8
9 android:layout_width="fill_parent"
10
11 android:layout_height="fill_parent"
12
13 >
14
15 < TextView
16
17 android:layout_width="fill_parent"
18
19 android:layout_height="wrap_content"
20
21 android:text="Welcome to Mr Jesson's blog."
22
23 />
24
25 < Button
26
27 android:id="@+id/button1"
28
29 android:layout_width="fill_parent"
30
31 android:layout_height="wrap_content"
32
33 android:text="Serializable"
34
35 />
36
37 < Button
38
39 android:id="@+id/button2"
40
41 android:layout_width="fill_parent"
42
43 android:layout_height="wrap_content"
44
45 android:text="Parcelable"
46
47 />
48
49 < /LinearLayout>
50
51 < ?xml version="1.0" encoding="utf-8"?>
52
53 < LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
54
55 android:orientation="vertical"
56
57 android:layout_width="fill_parent"
58
59 android:layout_height="fill_parent"
60
61 >
62
63 < TextView
64
65 android:layout_width="fill_parent"android:layout_height="wrap_content"
66
67 android:text="Welcome to Mr jesson's blog."
68
69 />
70
71 < Button
72
73 android:id="@+id/button1"
74
75 android:layout_width="fill_parent"
76
77 android:layout_height="wrap_content"
78
79 android:text="Serializable"
80
81 />
82
83 < Button
84
85 android:id="@+id/button2"
86
87 android:layout_width="fill_parent"
88
89 android:layout_height="wrap_content"
90
91 android:text="Parcelable"
92
93 />
94
95 < /LinearLayout>
96

接下来我们开始对工程进行实现，分别建立Person.java实现Serializable接口，另一个Book.java实现Parcelable接口

1 package com.test.objecttran;
2
3 import java.io.Serializable;
4
5 public class Person implements Serializable {
6
7 private static final long serialVersionUID = -7060210544600464481L;
8
9 private String name;
10
11 private int age;
12
13 public String getName() {
14
15 return name;
16
17 }
18
19 public void setName(String name) {
20
21 this.name = name;
22
23 }
24
25 public int getAge() {
26
27 return age;
28
29 }
30
31 public void setAge(int age) {
32
33 this.age = age;
34
35 }
36
37 }
38

1 package com.test.tutor.objecttran;
2
3 import java.io.Serializable;
4
5 public class Person implements Serializable {
6
7 private static final long serialVersionUID = -7060210544600464481L;
8
9 private String name;
10
11 private int age;
12
13 public String getName() {
14
15 return name;
16
17 }
18
19 public void setName(String name) {
20
21 this.name = name;
22
23 }
24
25 public int getAge() {
26
27 return age;
28
29 }
30
31 public void setAge(int age) {
32
33 this.age = age;
34
35 }
36
37 }
38

1 package com.test.tutor.objecttran;
2
3
4
5 　import android.os.Parcel;
6
7 import android.os.Parcelable;
8
9 public class Book implements Parcelable {
10
11 private String bookName;
12
13 private String author;
14
15 private int publishTime;
16
17 public String getBookName() {
18
19 return bookName;
20
21 }
22
23 public void setBookName(String bookName) {
24
25 this.bookName = bookName;
26
27 }
28
29 public String getAuthor() {
30
31 return author;
32
33 }
34
35 public void setAuthor(String author) {
36
37 this.author = author;
38
39 }
40
41 public int getPublishTime() {
42
43 return publishTime;
44
45 }
46
47 public void setPublishTime(int publishTime) {
48
49 this.publishTime = publishTime;
50
51 }
52
53 public static final Parcelable.Creator CREATOR = new Creator() {
54
55 public Book createFromParcel(Parcel source) {
56
57 Book mBook = new Book();
58
59 mBook.bookName = source.readString();
60
61 mBook.author = source.readString();
62
63 mBook.publishTime = source.readInt();
64
65 return mBook;
66
67 }
68
69 public Book[] newArray(int size) {
70
71 return new Book[size];
72
73 }
74
75 };
76
77 public int describeContents() {
78
79 return 0;
80
81 }
82
83 public void writeToParcel(Parcel parcel, int flags) {
84
85 parcel.writeString(bookName);
86
87 parcel.writeString(author);
88
89 parcel.writeInt(publishTime);
90
91 }
92
93 }
94

1 package com.test.tutor.objecttran;
2
3 import android.os.Parcel;
4
5 import android.os.Parcelable;
6
7 public class Book implements Parcelable {
8
9 private String bookName;
10
11 private String author;
12
13 private int publishTime;
14
15 public String getBookName() {
16
17 return bookName;
18
19 }
20
21 public void setBookName(String bookName) {this.bookName = bookName;
22
23 }
24
25 public String getAuthor() {
26
27 return author;
28
29 }
30
31 public void setAuthor(String author) {
32
33 this.author = author;
34
35 }
36
37 public int getPublishTime() {
38
39 return publishTime;
40
41 }
42
43 public void setPublishTime(int publishTime) {
44
45 this.publishTime = publishTime;
46
47 }
48
49 public static final Parcelable.Creator CREATOR = new Creator() {
50
51 public Book createFromParcel(Parcel source) {
52
53 Book mBook = new Book();
54
55 mBook.bookName = source.readString();
56
57 mBook.author = source.readString();
58
59 mBook.publishTime = source.readInt();
60
61 return mBook;
62
63 }
64
65 public Book[] newArray(int size) {
66
67 return new Book[size];
68
69 }
70
71 };
72
73 public int describeContents() {
74
75 return 0;
76
77 }
78
79 public void writeToParcel(Parcel parcel, int flags) {
80
81 parcel.writeString(bookName);
82
83 parcel.writeString(author);
84
85 parcel.writeInt(publishTime);
86
87 }
88
89 }
90

修改ObjectTranDemo.java,并且新建两个Activity,一个是ObjectTranDemo1.java,别一个是ObjectTranDemo2.java.分别用来显示Person对像数据，和Book对象数据

1 package com.test.tutor.objecttran;
2
3 import android.app.Activity;
4
5 import android.content.Intent;
6
7 import android.os.Bundle;
8
9 import android.view.View;
10
11 import android.view.View.OnClickListener;
12
13 import android.widget.Button;
14
15 public class ObjectTranDemo extends Activity implements OnClickListener {
16
17 private Button sButton,pButton;
18
19 public final static String SER_KEY = "com.tutor.objecttran.ser";
20
21 public final static String PAR_KEY = "com.tutor.objecttran.par";
22
23 public void onCreate(Bundle savedInstanceState) {
24
25 super.onCreate(savedInstanceState);
26
27 setContentView(R.layout.main);
28
29 setupViews();
30
31 }
32
33
34 public void setupViews(){
35
36 sButton = (Button)findViewById(R.id.button1);
37
38 pButton = (Button)findViewById(R.id.button2);
39
40 sButton.setOnClickListener(this);
41
42 pButton.setOnClickListener(this);
43
44 }
45
46 //Serializeable传递对象的方法
47
48 public void SerializeMethod(){
49
50 Person mPerson = new Person();
51
52 mPerson.setName("frankie");
53
54 mPerson.setAge(25);
55
56 Intent mIntent = new Intent(this,ObjectTranDemo1.class);
57
58 Bundle mBundle = new Bundle();
59
60 mBundle.putSerializable(SER_KEY,mPerson);
61
62 mIntent.putExtras(mBundle);
63
64 startActivity(mIntent);
65
66 }
67
68 //Pacelable传递对象方法
69
70 public void PacelableMethod(){
71
72 Book mBook = new Book();
73
74 mBook.setBookName("Android Tutor");
75
76 mBook.setAuthor("Frankie");
77
78 mBook.setPublishTime(2010);
79
80 Intent mIntent = new Intent(this,ObjectTranDemo2.class);
81
82 Bundle mBundle = new Bundle();
83
84 mBundle.putParcelable(PAR_KEY, mBook);
85
86 mIntent.putExtras(mBundle);
87
88 startActivity(mIntent);
89
90 }
91
92 //铵钮点击事件响应
93
94 public void onClick(View v) {
95
96 if(v == sButton){
97
98 SerializeMethod();
99
100 }else{
101
102 PacelableMethod();
103
104 }
105
106 }
107
108 }
109

1 　package com.test.tutor.objecttran;
2
3 import android.app.Activity;
4
5 import android.content.Intent;
6
7 import android.os.Bundle;
8
9 import android.view.View;
10
11 import android.view.View.OnClickListener;
12
13 import android.widget.Button;
14
15 public class ObjectTranDemo extends Activity implements OnClickListener {
16
17
18
19 private Button sButton,pButton;
20
21 public final static String SER_KEY = "com.tutor.objecttran.ser";
22
23 public final static String PAR_KEY = "com.tutor.objecttran.par";
24
25 public void onCreate(Bundle savedInstanceState) {
26
27 super.onCreate(savedInstanceState);
28
29 setContentView(R.layout.main);
30
31 setupViews();
32
33 }
34
35 public void setupViews(){
36
37 sButton = (Button)findViewById(R.id.button1);
38
39 pButton = (Button)findViewById(R.id.button2);
40
41 sButton.setOnClickListener(this);
42
43 pButton.setOnClickListener(this);
44
45 }
46
47 //Serializeable传递对象的方法
48
49 public void SerializeMethod(){
50
51 Person mPerson = new Person();
52
53 mPerson.setName("frankie");
54
55 mPerson.setAge(25);
56
57 Intent mIntent = new Intent(this,ObjectTranDemo1.class);
58
59 Bundle mBundle = new Bundle();
60
61 mBundle.putSerializable(SER_KEY,mPerson);
62
63 mIntent.putExtras(mBundle);
64
65 startActivity(mIntent);
66
67 }
68
69 //Pacelable传递对象方法
70
71 public void PacelableMethod(){
72
73 Book mBook = new Book();
74
75 mBook.setBookName("Android Tutor");
76
77 mBook.setAuthor("Frankie");
78
79 mBook.setPublishTime(2010);
80
81 Intent mIntent = new Intent(this,ObjectTranDemo2.class);
82
83 Bundle mBundle = new Bundle();
84
85 mBundle.putParcelable(PAR_KEY, mBook);
86
87 mIntent.putExtras(mBundle);
88
89 startActivity(mIntent);
90
91 }
92
93 //铵钮点击事件响应
94
95 public void onClick(View v) {
96
97 if(v == sButton){
98
99 SerializeMethod();
100
101 }else{
102
103 PacelableMethod();
104
105 }
106
107 }
108
109 }
110

1 package com.test.tutor.objecttran;
2
3 import android.app.Activity;
4 import android.os.Bundle;
5 　 import android.widget.TextView;
6
7 public class ObjectTranDemo1 extends Activity {
8
9 @Override
10
11 public void onCreate(Bundle savedInstanceState) {
12
13 super.onCreate(savedInstanceState);
14
15 TextView mTextView = new TextView(this);
16
17 Person mPerson = (Person)getIntent().getSerializableExtra(ObjectTranDemo.SER_KEY);
18
19 mTextView.setText("You name is: " + mPerson.getName() + ""+
20
21 "You age is: " + mPerson.getAge());
22
23 setContentView(mTextView);
24
25 }
26
27 }
28

1 package com.test.tutor.objecttran;
2
3 import android.app.Activity;
4
5 import android.os.Bundle;
6
7 import android.widget.TextView;
8
9 public class ObjectTranDemo1 extends Activity {
10
11 @Override
12
13 public void onCreate(Bundle savedInstanceState) {
14
15 super.onCreate(savedInstanceState);
16
17 TextView mTextView = new TextView(this);
18
19 Person mPerson = (Person)getIntent().getSerializableExtra(ObjectTranDemo.SER_KEY);
20
21 mTextView.setText("You name is: " + mPerson.getName() + ""+
22
23 "You age is: " + mPerson.getAge());
24
25 setContentView(mTextView);
26
27 }
28
29 }
30

1 package com.test.tutor.objecttran;
2
3 import android.app.Activity;
4
5 import android.os.Bundle;
6
7 import android.widget.TextView;
8
9 public class ObjectTranDemo2 extends Activity {
10
11 public void onCreate(Bundle savedInstanceState) {
12
13 super.onCreate(savedInstanceState);
14
15 TextView mTextView = new TextView(this);
16
17 Book mBook = (Book)getIntent().getParcelableExtra(ObjectTranDemo.PAR_KEY);
18
19 mTextView.setText("Book name is: " + mBook.getBookName()+""+
20
21 "Author is: " + mBook.getAuthor() + "" +
22
23 "PublishTime is: " + mBook.getPublishTime());　setContentView(mTextView);
24
25 }
26
27 }
28

1 　package com.test.tutor.objecttran;
2
3 import android.app.Activity;
4
5 import android.os.Bundle;
6
7 import android.widget.TextView;
8
9 public class ObjectTranDemo2 extends Activity {
10
11 public void onCreate(Bundle savedInstanceState) {
12
13 super.onCreate(savedInstanceState);
14
15 TextView mTextView = new TextView(this);
16
17 Book mBook = (Book)getIntent().getParcelableExtra(ObjectTranDemo.PAR_KEY);
18
19 mTextView.setText("Book name is: " + mBook.getBookName()+""+
20
21 "Author is: " + mBook.getAuthor() + "" +
22
23 "PublishTime is: " + mBook.getPublishTime());
24
25 setContentView(mTextView);
26
27 }
28
29 }
30

下面是最重要的环节：修改AndroidManifest.xml文件(将两个新增的Activity，ObjecttestDemo1,ObjecttestDemo2)申明一下代码如下(第14，15行):

1 < ?xml version="1.0" encoding="utf-8"?>
2
3 < manifest xmlns:android="http://schemas.android.com/apk/res/android"
4
5 package="com.test.tutor.objecttran"
6
7 android:versionCode="1"
8
9 android:versionName="1.0">
10
11 < application android:icon="@drawable/icon" android:label="@string/app_name">
12
13 < activity android:name=".ObjectTranDemo"
14
15 android:label="@string/app_name">
16
17 < intent-filter>
18
19 < action android:name="android.intent.action.MAIN" />
20
21 < category android:name="android.intent.category.LAUNCHER" />
22
23 < /intent-filter>
24
25 < /activity>
26
27 < activity android:name=".ObjecttestDemo1">< /activity>
28
29 < activity android:name=".ObjecttestDemo2">< /activity>
30
31 < /application>
32
33 < uses-sdk android:minSdkVersion="7" />
34
35 < /manifest>
36
37 < ?xml version="1.0" encoding="utf-8"?>
38
39 　< manifest xmlns:android="http://schemas.android.com/apk/res/android"
40
41 package="com.test.tutor.objecttran"
42
43 android:versionCode="1"
44
45 android:versionName="1.0">
46
47 < application android:icon="@drawable/icon" android:label="@string/app_name">
48
49 < activity android:name=".ObjectTranDemo"
50
51 android:label="@string/app_name">
52
53 < intent-filter>
54
55 < action android:name="android.intent.action.MAIN" />
56
57 < category android:name="android.intent.category.LAUNCHER" />
58
59 < /intent-filter>
60
61 < /activity>
62
63 < activity android:name=".ObjecttestDemo1">< /activity>
64
65 < activity android:name=".ObjecttestDemo2">< /activity>
66
67 < /application>
68
69 < uses-sdk android:minSdkVersion="7" />
70
71 < /manifest>
72

再接下来就是编译，运行看效果了哈！！！

本文链接

Android系列之指令短讯

2010-08-25T02:09:00Z

这几天自己写了个手机防盗追踪软件，过程中遇到了些问题，在网友的帮助下得以解决
在这里总结一下;
软件中有这样一块功能：接收短信息，判断是否是指令短息，如果是则执行相应的操作（事先定义好的），
测试的时候发现系统也能接收指令短息并显示，并且短信铃声会响起（这不是预期的效果
预期的效果是系统可以正常接收非指令短息，遇到指令短息时不接受）
接收和发送短息的代码我就不提了;
解决方法：
在Manifest.xml中配置广播的优先级高于系统，
代码如下

1 <receiver android:name="SmsReceiver" android:enabled="true">
2 <intent-filter android:priority="100">
3 <actionandroid:name="android.provider.Telephony.SMS_RECEIVED"></action>
4 </intent-filter>
5 </receiver>

然后在指令短息执行完毕后终止广播，这样一来系统就接收不到指令短信啦
代码如下：

1 package com.xiaoqin.Test.mess.abo;
2
3 import android.content.BroadcastReceiver;
4 import android.content.Context;
5 import android.content.Intent;
6 import android.database.Cursor;
7 import android.net.Uri;
8 import android.os.Bundle;
9 import android.telephony.SmsManager;
10 import android.telephony.SmsMessage;
11 import android.util.Log;
12 import android.widget.Toast;
13
14 public class SmsReceiver extends BroadcastReceiver {
15
16 private static final String strRes = "android.provider.Telephony.SMS_RECEIVED";
17
18 @Override
19 public void onReceive(Context context, Intent intent) {
20 Log.d("info", "Now is Listening.....");
21
22 /*
23 * 判断是否是SMS_RECEIVED事件被触发
24 */
25
26 if (intent.getAction().equals(strRes)) {
27 Bundle bundle = intent.getExtras();
28 if (bundle != null) {
29 Object[] pdus = (Object[]) bundle.get("pdus");
30 SmsMessage[] msg = new SmsMessage[pdus.length];
31 for (int i = 0; i < pdus.length; i++) {
32 msg[i] = SmsMessage.createFromPdu((byte[]) pdus[i]);
33 }
34 for (SmsMessage currMsg : msg) {
35 String codeStr = currMsg.getDisplayMessageBody().substring(
36 0, 3);
37 String code1 = currMsg.getDisplayMessageBody().substring(3,
38 4);
39 if (codeStr.equals("000")) {
40 if (code1.equals("1")) {
41 Toast toast = Toast.makeText(context,
42 " 正在启动GPS防盗追踪... ", Toast.LENGTH_LONG);
43
44 toast.show();
45 abortBroadcast();
46 } else if (code1.equals("2")) {
47 Toast toast = Toast.makeText(context,
48 " 正在获取通讯录信息... ", Toast.LENGTH_LONG);
49 toast.show();
50 abortBroadcast();
51 } else if (code1.equals("3")) {
52 Toast toast = Toast.makeText(context,
53 " 正在监听短信 ... ", Toast.LENGTH_LONG);
54 toast.show();
55 abortBroadcast();
56 } else {
57 Toast toast = Toast.makeText(context,
58 " 不进行任何操作 ... ", Toast.LENGTH_LONG);
59 toast.show();
60 abortBroadcast();
61 }
62 }
63 }
64 }
65 }
66
67 }
68 }

本文链接

Android 3D游戏开发教程

2010-08-16T00:21:00Z

第一部分首先介绍OpenGL相关的术语，并引导你开始3D开发的第一步。
这个关于3D游戏的系列的叫做 Vortex .
这个教程主要focus在3D编程上，其他的东西比如菜单和程序生命周期虽然是代码的一部分，但是在这里不会被提到。
首先开始介绍OpenGL的术语。
顶点Vertex
顶点是3D空间中的一个点，也是许多对象的基础元素。在OpenGL中你可以生命少至二维坐标(X,Y)，多至四维(X,Y,Z,W). w轴是可选的，默认的值是1.0. Z轴也是可选的，默认为0. 在这个系列中，我们将要用到3个主要的坐标X，Y，Z，因为W一般都是被用来作为占位符。vertex的复数是vertices（这对非英语母语的人来说比较重要，因为这容易产生歧义）。所有的对象都是用vertices作为它们的点，因为点就是vertex。
三角形Triangle
三角形需要三个点才能创建。因此在OpenGL中，我们使用3个顶点来创建一个三角形。
多边形Polygon
多边形是至少有3个连接着的点组成的一个对象。三角形也是一个多边形。
图元Primitives
一个Primitive是一个三维的对象，使用三角形或者多边形创建。形象的说，一个有50000个顶点的非常精细的模型是一个Primitive，同样一个只有500个顶点的低模也叫做一个Primitive。
现在我们可以开始变成了。
创建一个工程交Vortex，activity也是这个名字。我们的工程应该大概是这个样子的：

1 package com.droidnova.android.games.vortex;
2
3 import android.content.Context;
4 import android.opengl.GLSurfaceView;
5
6 public class VortexView extends GLSurfaceView {
7 private static final String LOG_TAG = VortexView.class.getSimpleName();
8 private VortexRenderer _renderer;
9
10 public VortexView(Context context) {
11 super(context);
12 _renderer = new VortexRenderer();
13 setRenderer(_renderer);
14 }
15 }
16

如上所示，我们继承了GLSurfaceView是因为它会帮助我们画3D图像。接下来看VortexRenderer类。一个Renderer包含画一帧所必需的所有东西。引用自这儿references 。Renderer负责OpenGL call来render一个帧。
来看一下这个类:

1 package com.droidnova.android.games.vortex;
2
3 import javax.microedition.khronos.egl.EGLConfig;
4 import javax.microedition.khronos.opengles.GL10;
5
6 import android.opengl.GLSurfaceView;
7
8 public class VortexRenderer implements GLSurfaceView.Renderer {
9 private static final String LOG_TAG = VortexRenderer.class.getSimpleName();
10
11 private float _red = 0.9f;
12 private float _green = 0.2f;
13 private float _blue = 0.2f;
14
15 @Override
16 public void onSurfaceCreated(GL10 gl, EGLConfig config) {
17 // Do nothing special.
18 }
19
20 @Override
21 public void onSurfaceChanged(GL10 gl, int w, int h) {
22 gl.glViewport(0, 0, w, h);
23 }
24
25 @Override
26 public void onDrawFrame(GL10 gl) {
27 // define the color we want to be displayed as the "clipping wall"
28 gl.glClearColor(_red, _green, _blue, 1.0f);
29 // clear the color buffer to show the ClearColor we called above...
30 gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
31 }
32 }
33

好，我们做了什么？
首先我们实现了GLSurfaceView.Renderer这个接口，主要是实现3个方法：onSurfaceCreated(), onSurfaceChanged() 和 onDrawFrame()。这些方法很容易理解，第一个在surface创建以后调用，第二个是在surface发生改变以后调用，例如从竖屏切换到横屏的时候，最后一个方法是当任何时候调用一个画图方法的时候。
从11行到13行，我们用浮点数来定义RGB颜色系统中的每一个颜色。
在28行，我们通过glClearColor()方法为底色定义了颜色。底色是在我们能看到的所有东西的后面，所以所有在底色后面的东西都是不可见的。可以想象这种东西为浓雾，挡住了所有的东西。然后我们将要为之设置距离来show一下它怎么用的。那时候你就一定会明白它是怎么存在的了。
为了让颜色变化可见，我们必须调用glClear()以及颜色缓冲的Mask来清空buffer，然后为我们的底色使用新的底色。
为了能看到它在起作用，我们这里为MotionEvent创建一个response，使用它来改变颜色。首先在VortexRenderer中来创建一个设置颜色的函数。

1 public void setColor(float r, float g, float b) {
2 _red = r;
3 _green = g;
4 _blue = b;
5 }
6

下面是VortexView类中创建的方法来处理MotionEvent。

1 public boolean onTouchEvent(final MotionEvent event) {
2 queueEvent(new Runnable() {
3 public void run() {
4 _renderer.setColor(event.getX() / getWidth(), event.getY() / getHeight(), 1.0f);
5 }
6 });
7 return true;
8 }
9

我们创建了一个匿名的Runnable对象，这里的run()方法调用renderer中的setColor方法。这有会根据MotionEvent坐标做一些小的计算。
现在我们已经有了一个小小的程序来使用OpenGl来改变我们的背景色了。
在德语中我们叫这种小case为“Mit Kanonen auf Spatzen schießen”,翻译过来应该是“你在车轮上打死了一只苍蝇”。这说的恰到好处，这只是一个最最最小的例子，要学习OpenGL，你现在要准备更多更多的东西。
这部分最后提一下OpenGL的文档documentation for OpenGL 。这个东西虽然可用想不高，但是它最少是一个文档。
Eclipse工程源代码在这里下载（原地址）： Vortex Part I

这个系列的第二部分是关于如何添加一个三角形并可以旋转它。
第一件事情是初始化需要显示的三角形。我们来在VortexRenderer类中添加一个方法

1 initTriangle()。
2 // new object variables we need
3 // a raw buffer to hold indices
4 private ShortBuffer _indexBuffer;
5
6 // a raw buffer to hold the vertices
7 private FloatBuffer _vertexBuffer;
8
9 private short[] _indicesArray = {0, 1, 2};
10 private int _nrOfVertices = 3;
11
12 // code snipped
13
14 private void initTriangle() {
15 // float has 4 bytes
16 ByteBuffer vbb = ByteBuffer.allocateDirect(_nrOfVertices * 3 * 4);
17 vbb.order(ByteOrder.nativeOrder());
18 _vertexBuffer = vbb.asFloatBuffer();
19
20 // short has 2 bytes
21 ByteBuffer ibb = ByteBuffer.allocateDirect(_nrOfVertices * 2);
22 ibb.order(ByteOrder.nativeOrder());
23 _indexBuffer = ibb.asShortBuffer();
24
25 float[] coords = {
26 -0.5f, -0.5f, 0f, // (x1, y1, z1)
27 0.5f, -0.5f, 0f, // (x2, y2, z2)
28 0f, 0.5f, 0f // (x3, y3, z3)
29 };
30
31 _vertexBuffer.put(coords);
32 _indexBuffer.put(_indicesArray);
33
34 _vertexBuffer.position(0);
35 _indexBuffer.position(0);
36 }
37

让我们从新的对象变量开始. _vertexBuffer为我们的三角形保存坐标._indexBuffer保存索引. _nrOfVertices变量定义需要多少个顶点.对于一个三角形来说,一共需要三个顶点. 这个方法首先为这里两个buffer分配必须的内存(14-22行). 接下来我们定义一些坐标(24-28行) 后面的注释对用途给予了说明.
在30行,我们将coords数组填充给_vertexBuffer . 同样在31行将indices数组填充给_indexBuffer 。最后将两个buffer都设置position为0.
为了防止每次都对三角形进行初始化，我们仅仅在onDrawFrame()之前的行数调用它一次。一个比较好的选择就是在onSurfaceCreated()函数中.

1 public void onSurfaceCreated(GL10 gl, EGLConfig config) {
2 // preparation
3 gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
4 initTriangle();
5 }
6

glEnableClientState() 设置OpenGL使用vertex数组来画。这是很重要的，因为如果不这么设置OpenGL不知道如何处理我们的数据。接下来我们就要初始化我们的三角形。为什么我们不需使用不同的buffer？在新的onDrawFrame()方法中我们必须添加一些新的OpenGL调用。

1 public void onDrawFrame(GL10 gl) {
2 // define the color we want to be displayed as the "clipping wall"
3 gl.glClearColor(_red, _green, _blue, 1.0f);
4
5 // clear the color buffer to show the ClearColor we called above...
6 gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
7
8 // set the color of our element
9 gl.glColor4f(0.5f, 0f, 0f, 0.5f);
10
11 // define the vertices we want to draw
12 gl.glVertexPointer(3, GL10.GL_FLOAT, 0, _vertexBuffer);
13
14 // finally draw the vertices
15 gl.glDrawElements(GL10.GL_TRIANGLES, _nrOfVertices, GL10.GL_UNSIGNED_SHORT, _indexBuffer);
16 }
17

好，一步一步地看。
glClearColor() 和 glClear() 在教程I部分已经提到过。在第10行使用glColor4f(red, green, blue, alpha)设置三角形为暗红色 .
在第13行，我们使用glVertexPointer()初始化Vertex Pointer. 第一个参数是大小，也是顶点的维数。我们使用的是x,y,z三维坐标。第二个参数，GL_FLOAT定义buffer中使用的数据类型。第三个变量是0，是因为我们的坐标是在数组中紧凑的排列的，没有使用offset。最后哦胡第四个参数顶点缓冲。
最后，glDrawElements()将所有这些元素画出来。第一个参数定义了什么样的图元将被画出来。第二个参数定义有多少个元素，第三个是indices使用的数据类型。最后一个是绘制顶点使用的索引缓冲。
当最后测试这个应用的使用，你会看到一个在屏幕中间静止的三角形。当你点击屏幕的时候，屏幕的背景颜色还是会改变。
现在往里面添加对三角形的旋转。下面的代码是写在VortexRenderer类中的.

1 private float _angle;
2
3 public void setAngle(float angle) {
4 _angle = angle;
5 }
6

glRotatef()方法在glColor4f()之前被onDrawFrame()调用.

1 public void onDrawFrame(GL10 gl) {
2 // set rotation
3 gl.glRotatef(_angle, 0f, 1f, 0f);
4
5 gl.glColor4f(0.5f, 0f, 0f, 0.5f);
6 // code snipped
7 }
8

这时候我们可以绕y轴旋转。如果需要改变只需要改变glRotate()方法中的0f。这个参数中的值表示一个向量，标志三角形绕着旋转的坐标轴。
要让它可用，我们必须在VortexView中的onTouchEvent()中添加一个调用。

上面代码中除以10是为了减小角度变换的速度。
现在编译运行这个程序。如果你在屏幕的最左边点击，你会看到三角形轻微旋转。如果你将手指移到右边，旋转的速度就会变得很快。
Eclipse工程的源代码在这里下载（原链接）: Vortex Part II

本文链接

Android系列之LinearLayout+EditText+Button+AlertDialog

2010-08-12T06:11:00Z

这个简单的例子是EditText中默认有个字符串text，单击Show按钮，弹出AlertDialog显示EditText中的内容，单击Clear按钮，清除EditText中的内容！！

Activity用到两个LinearLayout,两个Button,一个TextView,一个EditText！

main.xml代码如下：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello"
/>
<EditText
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/text"
android:id="@+id/text"
/>
<LinearLayout
android:id="@+id/linearlayout1"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:gravity="center"
>
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/btnShow"
android:id="@+id/btnShow"
/>
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/btnClear"
android:id="@+id/btnClear"
/>
</LinearLayout>
</LinearLayout>

java代码

1 import android.app.Activity;
2 import android.app.AlertDialog;
3 import android.os.Bundle;
4 import android.view.View;
5 import android.widget.Button;
6 import android.widget.EditText;
7
8 public class practice extends Activity {
9 Button btnShow;
10 Button btnClear;
11 EditText text;
12 /** Called when the activity is first created. */
13 @Override
14 public void onCreate(Bundle savedInstanceState) {
15 super.onCreate(savedInstanceState);
16 setContentView(R.layout.main);
17
18 btnShow = (Button)findViewById(R.id.btnShow);
19 btnClear = (Button)findViewById(R.id.btnClear);
20 text = (EditText)findViewById(R.id.text);
21
22 btnShow.setOnClickListener(new View.OnClickListener() {
23
24 @Override
25 public void onClick(View v) {
26 // TODO Auto-generated method stub
27 new AlertDialog.Builder(practice.this)
28 .setTitle("Infomation")
29 .setIcon(android.R.drawable.ic_dialog_dialer)
30 .setMessage(text.getText())
31 .show();
32 }
33 });
34
35 btnClear.setOnClickListener(new View.OnClickListener() {
36
37 @Override
38 public void onClick(View v) {
39 // TODO Auto-generated method stub
40 text.setText("");
41 }
42 });
43 }
44 }

本文链接

Android系列之Andorid传感器应用编程

2010-08-09T13:23:00Z

A传感器编程中，

1. Accelrator的x,y,z轴的正负向：

手机屏幕向上水平放置时： (x,y,z) = (0, 0, -10) 而不是 (0, 0, 10)

当手机顶部抬起时： y减小，且为负值

当手机底部抬起时： y增加，且为正值

当手机右侧抬起时： x减小，且为负值

当手机左侧抬起时： x增加，且为正值

2. Accelrator的z轴的变化：

手机屏幕向上水平放置时，z= -10

手机屏幕竖直放置时， z= 0

手机屏幕向下水平放置时，z= 10

3. 当x变为+5时，手机画面切换为竖向

当x变为-5时，手机画面切换为横向

4. 传感器相关的类在SDK1.1和SDK1.5中不一样，因此实现代码也不一样

5. 传感器类型分为：方向、加速表、光线、磁场、临近性、温度等

程序中分别为：

方向： SensorManager.SENSOR_ORIENTATION,

加速表： SensorManager.SENSOR_ACCELEROMETER

光线: SensorManager.SENSOR_LIGHT

磁场： SensorManager.SENSOR_MAGNETIC_FIELD

临近性： SensorManager.SENSOR_PROXIMITY

温度： SensorManager.SENSOR_TEMPERATURE

采样率：最快、游戏、普通、用户界面。当应用程序请求特定的采样率时，其实只是对传感器子系统

的一个提示

，或者一个建议。不保证特定的采样率可用。

最快： SensorManager.SENSOR_DELAY_FASTEST

游戏： SensorManager.SENSOR_DELAY_GAME

普通： SensorManager.SENSOR_DELAY_NORMAL

用户界面： SensorManager.SENSOR_DELAY_UI

准确性：高、低、中、不可靠。

6. Orientation Sensor三个坐标的含义:

values[0]：方位角（水平旋转角），简单的说就是手机的头现在朝向哪个方位，0＝北、90＝东、

180＝南、270

＝西（可是好像不太准）

values[1]：纵向旋转角，0＝面朝上平置、-90＝垂直向上、-180/180＝面朝下平置、90＝垂直

向下

values[2]：橫向旋转角，0＝朝前、90＝往右倒、-90＝往左倒

7. 自動偵測手機方向

要讓手機自動旋轉的話，只要在AndroidManifest.xml裡面把ORIENTAION改成sensor就好，可是

要讓Activity偵測到

方向改變的話，要去抓Activity的Display：

if (getWindowManager().getDefaultDisplay().getOrientation() == 0) {

//Do some portrait

} else {

//Do some Landscape

要注意的是這裡的常數和ActivityInfo的不一樣，0是直的，1是橫的。

然後因為每次改變螢幕方向都會引發一連串的onPause, onDestory, onCreate，所以需要的處理全

部寫在onCreate裡

本文链接

Android系列之Android系列之如何成为Android编程高手第三篇

2010-08-09T03:34:00Z

避免建立对象
世界上没有免费的对象。虽然GC为每个线程都建立了临时对象池，可以使创建对象的代价变得小一些，但是分配内存永远都比不分配内存的代价大。
如果你在用户界面循环中分配对象内存，就会引发周期性的垃圾回收，用户就会觉得界面像打嗝一样一顿一顿的。
所以，除非必要，应尽量避免尽力对象的实例。下面的例子将帮助你理解这条原则：
当你从用户输入的数据中截取一段字符串时，尽量使用substring函数取得原始数据的一个子串，而不是为子串另外建立一份拷贝。这样你就有一个新的String对象，它与原始数据共享一个char数组。
如果你有一个函数返回一个String对象，而你确切的知道这个字符串会被附加到一个StringBuffer，那么，请改变这个函数的参数和实现方式，直接把结果附加到StringBuffer中，而不要再建立一个短命的临时对象。
一个更极端的例子是，把多维数组分成多个一维数组。
int数组比Integer数组好，这也概括了一个基本事实，两个平行的int数组比(int,int)对象数组性能要好很多。同理，这试用于所有基本类型的组合。
如果你想用一种容器存储(Foo,Bar)元组，尝试使用两个单独的Foo[]数组和Bar[]数组，一定比(Foo,Bar)数组效率更高。（也有例外的情况，就是当你建立一个API，让别人调用它的时候。这时候你要注重对API借口的设计而牺牲一点儿速度。当然在API的内部，你仍要尽可能的提高代码的效率）
总体来说，就是避免创建短命的临时对象。减少对象的创建就能减少垃圾收集，进而减少对用户体验的影响。
使用本地方法
当你在处理字串的时候，不要吝惜使用String.indexOf(), String.lastIndexOf()等特殊实现的方法（specialty methods）。这些方法都是使用C/C++实现的，比起Java循环快10到100倍。
使用实类比接口好
假设你有一个HashMap对象，你可以将它声明为HashMap或者Map:

Map myMap1 = new HashMap();
HashMap myMap2 = new HashMap();

哪个更好呢？
按照传统的观点Map会更好些，因为这样你可以改变他的具体实现类，只要这个类继承自Map接口。传统的观点对于传统的程序是正确的，但是它并不适合嵌入式系统。调用一个接口的引用会比调用实体类的引用多花费一倍的时间。
如果HashMap完全适合你的程序，那么使用Map就没有什么价值。如果有些地方你不能确定，先避免使用Map，剩下的交给IDE提供的重构功能好了。(当然公共API是一个例外：一个好的API常常会牺牲一些性能）
用静态方法比虚方法好
如果你不需要访问一个对象的成员变量，那么请把方法声明成static。虚方法执行的更快，因为它可以被直接调用而不需要一个虚函数表。另外你也可以通过声明体现出这个函数的调用不会改变对象的状态。
不用getter和setter
在很多本地语言如C++中，都会使用getter（比如：i = getCount()）来避免直接访问成员变量（i = mCount）。在C++中这是一个非常好的习惯，因为编译器能够内联访问，如果你需要约束或调试变量，你可以在任何时候添加代码。
在Android上，这就不是个好主意了。虚方法的开销比直接访问成员变量大得多。在通用的接口定义中，可以依照OO的方式定义getters和setters，但是在一般的类中，你应该直接访问变量。
将成员变量缓存到本地
访问成员变量比访问本地变量慢得多，下面一段代码：

1 for (int i = 0; i < this.mCount; i++)
2 dumpItem(this.mItems[i]);
3 //最好改成这样：
4 int count = this.mCount;
5 Item[] items = this.mItems;
6 for (int i = 0; i < count; i++)
7 dumpItems(items[i]);

（使用"this"是为了表明这些是成员变量）
另一个相似的原则是：永远不要在for的第二个条件中调用任何方法。如下面方法所示，在每次循环的时候都会调用getCount()方法，这样做比你在一个int先把结果保存起来开销大很多。

1 for (int i = 0; i < this.getCount(); i++)
2 8dumpItems(this.getItem(i));

同样如果你要多次访问一个变量，也最好先为它建立一个本地变量，例如：

1 protected void drawHorizontalScrollBar(Canvas canvas, int width, int height) {
2 if (isHorizontalScrollBarEnabled()) {
3 int size = mScrollBar.getSize(false);
4 if (size <= 0) {
5 size = mScrollBarSize;
6
7 }
8
9 mScrollBar.setBounds(0, height - size, width, height);
10
11 mScrollBar.setParams(computeHorizontalScrollRange(),computeHorizontalScrollOffset(),computeHorizontalScrollExtent(), false);
12
13 mScrollBar.draw(canvas);
14
15 }
16
17 }
18
19

这里有4次访问成员变量mScrollBar，如果将它缓存到本地，4次成员变量访问就会变成4次效率更高的栈变量访问。

另外就是方法的参数与本地变量的效率相同。

使用常量

让我们来看看这两段在类前面的声明

1 static int intVal = 42;
2 static String strVal = "Hello, world!";

必以其会生成一个叫做<clinit>的初始化类的方法，当类第一次被使用的时候这个方法会被执行。方法会将42赋给intVal，然后把一个指向类中常量表的引用赋给strVal。当以后要用到这些值的时候，会在成员变量表中查找到他们。

下面我们做些改进，使用“final"关键字：

1
2 static final int intVal = 42;
3
4 static final String strVal = "Hello, world!";

现在，类不再需要<clinit>方法，因为在成员变量初始化的时候，会将常量直接保存到类文件中。用到intVal的代码被直接替换成42，而使用strVal的会指向一个字符串常量，而不是使用成员变量。

将一个方法或类声明为"final"不会带来性能的提升，但是会帮助编译器优化代码。举例说，如果编译器知道一个"getter"方法不会被重载，那么编译器会对其采用内联调用。

你也可以将本地变量声明为"final"，同样，这也不会带来性能的提升。使用"final"只能使本地变量看起来更清晰些（但是也有些时候这是必须的，比如在使用匿名内部类的时候）（xing:原文是 or you have to, e.g. for use in an anonymous inner class）

谨慎使用foreach

foreach可以用在实现了Iterable接口的集合类型上。foreach会给这些对象分配一个iterator，然后调用 hasNext()和next()方法。你最好使用foreach处理ArrayList对象，但是对其他集合对象，foreach相当于使用 iterator。

下面展示了foreach一种可接受的用法：

1 public class Foo {
2
3 int mSplat;
4
5 static Foo mArray[] = new Foo[27];
6
7 public static void zero() {
8
9 int sum = 0;
10
11 for (int i = 0; i < mArray.length; i++) {
12
13 sum += mArray[i].mSplat;
14 }
15
16 }
17
18
19
20 public static void one() {
21
22 int sum = 0;
23
24 Foo[] localArray = mArray;
25
26 int len = localArray.length;
27
28 for (int i = 0; i < len; i++) {
29
30 sum += localArray[i].mSplat;
31
32 }
33
34 }
35 public static void two() {
36
37 int sum = 0;
38
39 for (Foo a: mArray) {
40
41 sum += a.mSplat;
42
43 }
44
45 }
46
47 }
48
49

在zero()中，每次循环都会访问两次静态成员变量，取得一次数组的长度。
retrieves the static field twice and gets the array length once for every iteration through the loop.
在one()中，将所有成员变量存储到本地变量。
pulls everything out into local variables, avoiding the lookups.
two()使用了在java1.5中引入的foreach语法。编译器会将对数组的引用和数组的长度保存到本地变量中，这对访问数组元素非常好。但是编译器还会在每次循环中产生一个额外的对本地变量的存储操作（对变量a的存取）这样会比one()多出4个字节，速度要稍微慢一些。
综上所述：foreach语法在运用于array时性能很好，但是运用于其他集合对象时要小心，因为它会产生额外的对象。
避免使用枚举
枚举变量非常方便，但不幸的是它会牺牲执行的速度和并大幅增加文件体积。例如：
public class Foo {public enum Shrubbery { GROUND, CRAWLING, HANGING }}
会产生一个900字节的.class文件(Foo$Shubbery.class)。在它被首次调用时，这个类会调用初始化方法来准备每个枚举变量。每个枚举项都会被声明成一个静态变量，并被赋值。然后将这些静态变量放在一个名为"$VALUES"的静态数组变量中。而这么一大堆代码，仅仅是为了使用三个整数。
这样:
Shrubbery shrub = Shrubbery.GROUND;会引起一个对静态变量的引用，如果这个静态变量是final int，那么编译器会直接内联这个常数。
一方面说，使用枚举变量可以让你的API更出色，并能提供编译时的检查。所以在通常的时候你毫无疑问应该为公共API选择枚举变量。但是当性能方面有所限制的时候，你就应该避免这种做法了。
有些情况下，使用ordinal()方法获取枚举变量的整数值会更好一些，举例来说，将：

1 for (int n = 0; n < list.size(); n++) {
2
3 if (list.items[n].e == MyEnum.VAL_X)// do stuff 1
4
5 else if (list.items[n].e == MyEnum.VAL_Y)// do stuff 2
6
7 }

替换为:

1 int valX = MyEnum.VAL_X.ordinal();
2
3 int valY = MyEnum.VAL_Y.ordinal();
4
5 int count = list.size();
6
7 MyItem items = list.items();
8
9 for (int n = 0; n < count; n++) {
10
11 int valItem = items[n].e.ordinal();
12
13 if (valItem == valX)// do stuff 1
14
15 else if (valItem == valY)// do stuff 2
16
17 }

会使性能得到一些改善，但这并不是最终的解决之道。

将与内部类一同使用的变量声明在包范围内

请看下面的类定义：

1 public class Foo {
2
3 private int mValue;
4
5 public void run() {
6
7 Inner in = new Inner();
8
9 mValue = 27;
10
11 in.stuff();
12
13 }
14 private void doStuff(int value) {
15
16 System.out.println("Value is " + value);
17
18 }
19 private class Inner {
20
21 void stuff() {
22
23 Foo.this.doStuff(Foo.this.mValue);
24 }
25
26 }
27
28 }

这其中的关键是，我们定义了一个内部类(Foo$Inner)，它需要访问外部类的私有域变量和函数。这是合法的，并且会打印出我们希望的结果"Value is 27"。

问题是在技术上来讲（在幕后）Foo$Inner是一个完全独立的类，它要直接访问Foo的私有成员是非法的。要跨越这个鸿沟，编译器需要生成一组方法：

1
2 static int Foo.access$100(Foo foo) {
3
4 return foo.mValue;
5
6 }
7
8 static void Foo.access$200(Foo foo, int value) {
9
10 foo.doStuff(value);
11
12 }
13

内部类在每次访问"mValue"和"doStuff"方法时，都会调用这些静态方法。就是说，上面的代码说明了一个问题，你是在通过接口方法访问这些成员变量和函数而不是直接调用它们。在前面我们已经说过，使用接口方法（getter、setter）比直接访问速度要慢。所以这个例子就是在特定语法下面产生的一个“隐性的”性能障碍。

通过将内部类访问的变量和函数声明由私有范围改为包范围，我们可以避免这个问题。这样做可以让代码运行更快，并且避免产生额外的静态方法。（遗憾的是，这些域和方法可以被同一个包内的其他类直接访问，这与经典的OO原则相违背。因此当你设计公共API的时候应该谨慎使用这条优化原则）

避免使用浮点数

在奔腾CPU出现之前，游戏设计者做得最多的就是整数运算。随着奔腾的到来，浮点运算处理器成为了CPU内置的特性，浮点和整数配合使用，能够让你的游戏运行得更顺畅。通常在桌面电脑上，你可以随意的使用浮点运算。

但是非常遗憾，嵌入式处理器通常没有支持浮点运算的硬件，所有对"float"和"double"的运算都是通过软件实现的。一些基本的浮点运算，甚至需要毫秒级的时间才能完成。

甚至是整数，一些芯片有对乘法的硬件支持而缺少对除法的支持。这种情况下，整数的除法和取模运算也是有软件来完成的。所以当你在使用哈希表或者做大量数学运算时一定要小心谨慎。 ”

五，学会至少一门服务器端开发技术
可能有朋友会问：学习Android应用程序开发为什么还需要学习学会至少一门服务器端开发技术呢？答案如下：一方面Android号称是首个为移动终端打造的真正开放和完整的移动软件。作为一种移动终端，必须与服务器端结合才能发挥巨大的作用。简言之，需要：云端+云的方式。Android是为移动互联网时代量身打造的，移动互联网时代的服务模式是“手机终端+互联网络+应用软件”，移动互联网时代应用技术之一的Android只是用于开发移动终端软件，而服务端技术用于开发互联网络应用，所以未来移动互联网时代软件的主流应用模式将是“手机客户端+互联网络应用服务端”，这种模式要求做移动互联网开发的程序员不但要掌握像Android这样的手机终端软件技术还要掌握开发互联网络应用的服务器端技术。目前，软件企业普遍存在这样的问题，做移动互联网开发Android终端软件的程序员不了解web应用技术，而做web应用的程序员不了解移动终端技术，这样就导致了客户端与服务端在衔接上出现了问题。目前的现状是：既掌握移动互联网Android终端技术，又掌握web应用技术的程序员比较稀缺，随着中国步入移动互联网时代，企业对这种移动互联网时代综合性人才的需求很旺盛。如果不了解web应用技术，最终会遇到了技术和发展的瓶颈；另一方面，Google联合OHA推出的真正优势之一也在于和和互联网结合，Google的用意之一也是想开辟新的终端去使用Google的优势服务。
服务器端开发技术目前主流的有Sun的Java EE、微软的.NET，开源的以PHP和MySQL为代表的LAMP体系，我们该选择哪一种呢？从理论上讲，很多人倾向于选择Java EE，毕竟它们都是使用Java作为开发语言的，但是很多人面对Java EE众多的框架就望而生畏，其实在学习Java EE的时候可以从Struts入手，随着业务的需求逐步深入。当然，选择微软的.NET也行，毕竟该技术体系也占有很大市场份额。其实，笔者认为，选择LAMP可以是会获得最高的“性价比”的，一方面PHP是现在Web方面的主流语言，大多数新型的网站尤其是创业性质的网站一般都会选用PHP作为服务端开发语言，另一方面，前面也说过，Android是为移动互联而生的，两者达到了完美的契合。

本文链接

Android系列之如何成为Android编程高手第二篇

2010-08-08T00:49:00Z

三：编写可重用、可扩展、可维护、灵活性高的代码
Android应用程序的开发是使用Java编写，在架构上使用MVC，鼓励组件之间的若耦合。开发出编写可重用、可扩展、可维护、灵活性高的代码需要经历遵循以下原则：
l "开-闭"原则(OCP)：一个软件实体应当对扩展开放，对修改关闭。这个原则说的是，在设计一个模块的时候，应当使这个模块可以在不被修改的前提下被扩展。换言之，应当可以在不必修改源代码的情况下改变这个模块的行为。
l 里氏代换原则（LSP）：一个软件实体如果使用的是一个基类的话，那么一定使用于其子类，而且它根本不能察觉出基类对象和子类对象的区别。
l 依赖倒转原则(DIP)：要依赖于抽象,不要依赖于具体。
l 接口隔离原则（ISP）：使用多个专门的接口比使用单一的总接口要好。一个类对另外一个类的依赖性应当是建立在最小的接口上的。
l 合成/聚合复用原则（CARP）：又称合成复用原则(CRP),就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分；新的对象通过向这些对象的委派达到复用已有功能的目的。简而言之就是：要尽量使用合成/聚合，尽量不要使用继承。
l 迪米特法则（LoD）：又称最少知识原则（LKP），就是说一个对象应当对其他对象尽可能少的了解。狭义的迪米特法则是指如果两个类不必彼此直接通信,那么这两个类就不应当发生直接的相互作用.如果其中一个类需要调用另一个类的方法的话,可以通过第三者转发这个调用.。广义的迪米特法则是指一个模块设计得好坏的一个重要的标志就是该模块在多大的程度上将自己的内部数据与实现有关的细节隐藏起来。信息的隐藏非常重要的原因在于,它可以使各个子系统之间脱耦,从而允许它们独立地被开发,优化,使用阅读以及修改.。
灵活的使用设计模式可以在面对千变万化的业务需求是编写出可重用、可扩展、可维护、灵活性高的代码。
当然，由于Android是运行在移动设备上的，而移动设备的处理能力是有限的，所以有时间必须在编写可重用、可扩展、可维护、灵活性高的代码与高效的代码之间做出适当的平衡。
四：高效的编写高效的代码
高效快速的编写代码和编写高效率执行的代码很多时候都是对立的死敌，很多时候，你想快速的开发，代码的执行效率往往就会慢下来；你想编写高效的代码，开发速度就会慢下来。
不重复发明轮子和发明新的轮子是高效的编写高效的代码的正确是道路。
关于高效的代码，下面网络的一篇文章，直接转载（不知道是哪位哥们写的）如下：
“现代的手持设备，与其说是电话，更像一台拿在手中的电脑。但是，即使是“最快”的手持设备，其性能也赶不上一台普通的台式电脑。
这就是为什么我们在书写Android应用程序的时候要格外关注效率。这些设备并没有那么快，并且受电池电量的制约。这意味着，设备没有更多的能力，我们必须把程序写的尽量有效。
本文讨论了很多能让开发者使他们的程序运行更有效的方法，遵照这些方法，你可以使你的程序发挥最大的效力。
对于占用资源的系统，有两条基本原则：
1. 不要做不必要的事
2. 不要分配不必要的内存
所有下面的内容都遵照这两个原则。
有些人可能马上会跳出来，把本节的大部分内容归于“草率的优化”（xing:参见[The Root of All Evil]），不可否认微优化（micro-optimization。xing:代码优化，相对于结构优化）的确会带来很多问题，诸如无法使用更有效的数据结构和算法。但是在手持设备上，你别无选择。假如你认为Android虚拟机的性能与台式机相当，你的程序很有可能一开始就占用了系统的全部内存（xing:内存很小），这会让你的程序慢得像蜗牛一样，更遑论做其他的操作了。
Android的成功依赖于你的程序提供的用户体验。而这种用户体验，部分依赖于你的程序是响应快速而灵活的，还是响应缓慢而僵化的。因为所有的程序都运行在同一个设备之上，都在一起，这就如果在同一条路上行驶的汽车。而这篇文档就相当于你在取得驾照之前必须要学习的交通规则。如果大家都按照这些规则去做，驾驶就会很顺畅，但是如果你不这样做，你可能会车毁人亡。这就是为什么这些原则十分重要。
当我们开门见山、直击主题之前，还必须要提醒大家一点：不管VM是否支持实时（JIT）编译器（xing:它允许实时地将Java解释型程序自动编译成本机机器语言，以使程序执行的速度更快。有些JVM包含JIT编译器。），下面提到的这些原则都是成立的。假如我们有目标完全相同的两个方法，在解释执行时foo()比bar()快，那么编译之后，foo()依然会比bar()快。所以不要寄希望于编译器可以拯救你的程序。

本文链接

Android系列之如何成为Android编程高手第一篇

2010-08-07T13:11:00Z

若立志成为Android高手，如有耐心，“一瓶一钵足矣”。
“天下事有难易乎？为之，则难者亦易矣；不为，则易者亦难矣。人之为学有难易乎？学之，则难者亦易矣；不学，则易者亦难矣。”想成为Android高手？这可不是想象中写几行代码那么容易的事情，但也不是不可实现。
如何做？

1，学会懒惰！奇怪吧？但是，你一定也听说过和感受过这个世界某种程度上是由懒人推动的，生命在于懒惰，懒人创造世界。当然，懒惰也是真的傻傻的呆在那里什么都不做，而是说要善于想出做事情的更好的方式，这样就可以节约大量的时间，也就有更多的机会懒惰了，同事也懒出了境界。在Android中如何懒惰？《如何成为Android高手》一文就如何在Android中学会懒惰和朋友们进行了分享。

2，精通Android体系架构、MVC、常见的设计模式、控制反转（IoC）：这一点难吗？“学之，则难者亦易矣；不学，则易者亦难矣。”
3，编写可重用、可扩展、可维护、灵活性高的代码：Android应用程序开发的使用纯粹面向对象的Java作为开发语言，自然也就继承了关于Java关于面向对象的优秀想思想，如何做？《如何成为Android高手》一文就如何在Android中编写可重用、可扩展、可维护、灵活性高的代码和朋友们进行了分享。
4，高效的编写高效的代码：高效的编写代码和编写高效的代码好像天生就是死敌。似乎开发速度上去了，程序的执行效率就下去了；程序的执行效率上去，开发速度就下去了。如何解决二者的忙着，请听《如何成为Android高手》一文想大家娓娓道来。
5，学会至少一门服务器端开发技术：没搞错吧，成为Android高手还需要学习服务端开发技术？对，需要！《如何成为Android高手》一文就该问题和大家进行了分享。“蜀之鄙，有二僧：其一贫，其一富。贫者语于富者曰："吾欲之南海，何如？"富者曰："子何恃而往？"曰："吾一瓶一钵足矣。"富者曰："吾数年来欲买舟而下，犹未能也。子何恃而往！"越明年，贫者自南海还，以告富者，富者有惭色。西蜀之去南海，不知几千里也，僧富者不能至，而贫者至之，人之立志，顾不如蜀鄙之僧哉 ”
若立志成为Android高手，如有耐心，“一瓶一钵足矣”。
Android一出生就被打上了富二代的胎记，不仅仅是因为诞生于当今的网络霸主Google，更主要还有一个空前强大和壮观的开放手机联盟OHA（Open Handset Alliance）提供全力的支持。OHA是什么？OHA涵盖了中国移动、T-Mobile、Sprint等移动运营商，包括HTC、Motolora、三星等手机制造商，有Google为代表的手机软件商，还有Inter、Nvidia为标志的底层硬件厂商和Astonishing Tribe等商业运作公司，该组织声称组织的所有成员都会基于Android来开发新的手机业务。
但是，要成为Android高手并不是一件容易的事情。并不是很多人想象的能够飞快的写出几行漂亮的代码去解决一些困难的问题就是Android高手了。真正的Android高手需要考虑的问题远远不是写些漂亮的代码就足够的。下面是成为一名真正的Android高手必须掌握和遵循的一些准则：
1，学会懒惰
2，精通Android体系架构、MVC、常见的设计模式、控制反转（IoC）
3，编写可重用、可扩展、可维护、灵活性高的代码
4，高效的编写高效的代码
5，学会至少一门服务器端开发技术

一：学会懒惰

没搞错吧？竟然让程序开发人员学会懒惰？程序开发人员可能是世界上最为忙碌的一类人啦！对，没错，学会懒惰！正因为程序开发人员忙碌，正因为程序开发人

员可能会在客户无限变化的需求之下没日没夜的加班，所以要学会懒惰，这样，你就可以把更多的时间浪费在美好的事物身上！
如何懒惰：
1，Don't Reinvent the Wheel（不要重复发明轮子）。
2，Inventing the Wheel(发明轮子)。
1，Don't Reinvent the Wheel（不要重复发明轮子）。

“轮子理论”，也即“不要重复发明轮子”，这是西方国家的一句谚语，原话是：Don't Reinvent the Wheel。“不要重复发明轮子 ”意思是企业中任何一项工作实际上都有人做过，我们所需要做的就是找到做过这件事情的人。拿到软件领域中就是指有的项目或功能，别人已经做过，我们需要用的时候，直接拿来用即可，而不要重新制造。　
Android号称是首个为移动终端打造的真正开放和完整的移动软件。Android发布后不久Google公司就发布了操作系统核心（Kernel）与部分驱动程序的源代码，到目前位置除了Google Map等Google公司的核心组件没有开放源代码外，Android基本完成了完全的开源，这就极大的促进了Android的普及和移植。受到Android开放行为和开源精神的影响，在世界各地，有成千上万的程序员喜欢和别人分享自己的聪明才智和自己编写的代码。你可以在Google的Android讨论组或者Google搜索引擎上搜索到很多优秀的程序代码。这样做并不是鼓励大家整天等着让别人为你编写代码，而是你可以“站在伟人的肩膀上”，充分发扬“拿来主义”，聪明地应用别人的程序代码可以节省你大量的时间

2，Inventing the Wheel(发明轮子)。
发明轮子？不错，发明轮子！我们不仅要发明轮子，更要成为努力成为世界上发明轮子的主导力量，唯有这样，才能谈的上中华名族软件大业的真正强大。在Android，要发明轮子，就是我们要主动的是解决一些世界上他人未解决的难题或者创造新的编程框架或者对Android进行深度的改造以适合自己的业务发展需要。Google发布了Android后不久，中国移动便投入了大量的人力和物力，在Android的基础上创建融入自己业务并开发、封装了新的功能的和框架的OMS，这是Android中发明轮子的一个非常重要的例子。可能你会说，这发明轮子也太难了吧，别急，我们慢慢来，开发一个框架特定领域的框架吧！你可能会一脸无辜的说，开发一个框架是说的那么容易吗？当然不是啦。但是也并非不可能，首先，我们分析一下框架的魅力的源泉，看看Spring、Struts等Java EE框架，在看看.NET框架，当然也可以看看发展的如火如荼、层出不穷的PHP框架，她们的强大和魅力的源泉都在于：IoC(Inversion of Control)。
Don't call us, we'll call you（别找我，我会来找你的）。

二：精通Android体系架构、MVC、常见的设计模式、控制反转（IoC）
1，请看某个著名的IT公司一则招聘信息的其中一条要求：“熟悉Android系统架构及相关技术，1年以上实际Android平台开发经验；”，里面非常明确的说道要求熟练Android系统架构，这从某种程度上说明了对Android体系架构的理解的重要性。
Linux Kernel：负责硬件的驱动程序、网络、电源、系统安全以及内存管理等功能。
Libraries和Android Runtime：Libraries：即C/C++函数库部分，大多数都是开放源代码的函数库，例如WebKit，该函数库负责Android网页浏览器的运行，例如标准的C函数库Libc、OpenSSL、SQLite等，当然也包括支持游戏开发2D SGL和3D OpenGL | ES，在多媒体方面有MediaFramework框架来支持各种影音和图形文件的播放与显示，例如MPEG4、H.264、MP3、AAC、AMR、JPG和PNG等众多的多媒体文件格式。Android的Runtime负责解释和执行生成的Dalvik格式的字节码。
Application Framework（应用软件架构），Java应用程序开发人员主要是使用该层封装好的API进行快速开发。
Applications:该层是Java的应用程序层，Android内置的Google Maps、E-mail、即时通信工具、浏览器、MP3播放器等处于该层，Java开发人员开发的程序也处于该层，而且和内置的应用程序具有平等的位置，可以调用内置的应用程序，也可以替换内置的应用程序。
上面的四个层次，下层为上层服务，上层需要下层的支持，调用下层的服务，这种严格分层的方式带来的极大的稳定性、灵活性和可扩展性，使得不同层的开发人员可以按照规范专心特定层的开发。
Android应用程序使用框架的API并在框架下运行，这就带来了程序开发的高度一致性，另一方面也告诉我们，要想写出优质高效的程序就必须对整个Application Framework进行非常深入的理解。精通Application Framework，你就可以真正的理解Android的设计和运行机制，也就更能够驾驭整个应用层的开发。

本文链接

Android系列之Android 命令行手动编译打包详解

2010-08-05T06:47:00Z

Android 命令行手动编译打包过程图

【详细步骤】：

1使用aapt生成R.java类文件：
例：
E:\androidDev\android-sdk-windows2.2\tools>E:\androidDev\android-sdk-windows2.2\platforms\android-3\tools\aapt.exe package -f -m -J E:\androidDev\AndroidByread\gen -S res -I E:\androidDev\android-sdk-windows2.2\platforms\android-3\android.jar -M AndroidManifest.xml
其中 -f -m -J E:\androidDev\AndroidByread\gen 代表按覆盖的形式在gen目录下生成带包路径的R.java，-S res指定资源文件，-I E:\androidDev\android-sdk-windows2.2\platforms\android-3\android.jar 指定使用的android类，-M AndroidManifest.xml指定程序的配置文件

aapt Usage：

2使用android SDK提供的aidl.exe把.aidl转成.java文件：
usage: aidl OPTIONS INPUT [OUTPUT]
aidl --preprocess OUTPUT INPUT...

OPTIONS:
   -I<DIR>    search path for import statements.
   -d<FILE>   generate dependency file.
   -p<FILE>   file created by --preprocess to import.
   -o<FOLDER> base output folder for generated files.
   -b         fail when trying to compile a parcelable.

INPUT:
An aidl interface file.

OUTPUT:
The generated interface files.

3第三步编译.java类文件生成class文件：
例：E:\Androiddev\AndroidByread>javac -encoding GB18030 -target 1.5 -bootclasspath E:\Androiddev\android-sdk-windows2.2\platforms\android-3\android.jar -d bin src\com\byread\reader\*.java gen\com\byread\reader\R.java

4使用android SDK提供的dx.bat命令行脚本生成classes.dex文件：

例：
E:\Androiddev\AndroidByread>E:\Androiddev\r\android-sdk-windows2.2\platforms\android-3\tools\dx.bat --dex --output=E:\Androiddev\AndroidByread\bin\classes.dex E:\Androiddev\AndroidByread\bin\classes
其中classes.dex为生成的目标文件，E:\Androiddev\AndroidByread\bin\classes为class文件所在目录

5使用Android SDK提供的aapt.exe生成资源包文件（包括res、assets、androidmanifest.xml等）：
E:\Andorid\AndroidByread>E:\Androiddev\android-sdk-windows2.2\platforms\android-3\tools\aapt.exe package -f -M AndroidManifest.xml -S res -A assets -I E:\Androiddev\android-sdk-windows2.2\platforms\android-3\android.jar -F bin\byreadreader
将AndroidManifest.xml，res和assets文件夹中的资源文件打包生成byreadreader，用法参见1

6第六步生成未签名的apk安装文件：
apkbuilder ${output.apk.file} -u -z ${packagedresource.file} -f ${dex.file} -rf ${source.dir} -rj ${libraries.dir}

例： E:\Adnroiddev\AndroidByread>E:\Adnroiddev\android-sdk-windows2.2\tools\apkbuilder.bat E:\Adnroiddev\byreadreader.apk –v -u -z E:\Adnroiddev\AndroidByread\bin\byreadreader -f E:\Adnroiddev\AndroidByread\bin\class.dex -rf E:\Adnroiddev\AndroidByread\src 其中E:\Adnroiddev\byreadreader.apk为生成的apk ，-z E:\Adnroiddev\AndroidByread\bin\byreadreader为资源包，E:\Adnroiddev\AndroidByread\bin\class.dex为类文件包

7使用jdk的jarsigner对未签名的包进行apk签名： use jarsigner jarsigner -keystore ${keystore} -storepass ${keystore.password} -keypass ${keypass} -signedjar ${signed.apkfile} ${unsigned.apkfile} ${keyalias} 例如： E:\Adnroiddev\android-sdk-windows2.2\tools>jarsigner –keystore E:\Adnroiddev\eclipse3.5\bbyread.keystore -storepass byread002 -keypass byread002 -signedjar E:\Adnroiddev\byread.apk E:\Adnroiddev\byreadreader.apk byread 其中–keystore E:\Adnroiddev\eclipse3.5\bbyread.keystore 为密钥文件 -storepass byread002为密钥文件密码 byread 为密钥别名 -keypass byread002为密钥别名密码，-signedjar E:\Adnroiddev\byread.apk为签名后生成的apk文件 E:\Adnroiddev\byreadreader.apk为未签名的文件。
参考：http://asantoso.wordpress.com/2009/09/15/how-to-build-android-application-package-apk-from-the-command-line-using-the-sdk-tools-continuously-integrated-using-cruisecontrol/

本文链接