国产亚洲精品VA片在线播放,午夜影视日本亚洲欧洲精品一区,亚洲一级黄色大片

[转]不同格式证书导入keystore�Ҏ(gu��)��

calvin — Fri, 03 Feb 2012 02:06:00 GMT

摘要: Java 自带�? keytool 工具 ... 阅读全文

calvin 2012-02-03 10:06 发表评论

Android exchange 账户讄��

calvin — Mon, 30 Jan 2012 09:13:00 GMT

输入邮箱�Q�邮��p��Gmail邮箱�Q�就是后�~�@gmail.com 输入密码后下一�?
关键点： “服务器”一栏，默认为gmail.com�Q�应该改为�?font color="#FF0000">m.google.com”，然后�l�箋卛_��?img src ="http://www.tkk7.com/lihao336/aggbug/369036.html" width = "1" height = "1" />

calvin 2012-01-30 17:13 发表评论

setComponentEnabledSetting doesn't work on widget

calvin — Tue, 27 Dec 2011 06:14:00 GMT

PackageManager.setComponentEnabledSetting 可以用来��用某个�l��g�Q�包括activity�Q�receiver�{�等。被��用的组件会被持久化�?data/system/packages.xml中，如：

现在需要在�q�行时禁用某个widget�Q�同时有一个system property用来标识是否需要禁用�?br />因�ؓwidget实际上就是个reveiver�Q�它接收android.appwidget.action.APPWIDGET_UPDATE的action�Q�所以开始的思�\是：
创徏一个BroadcastReceiver�Q�接收Intent.ACTION_BOOT_COMPLETED�q�个动作�Q�从而在启动完成后调用SystemProperties.get("disable_widget")�Q�如果需要禁用这个widget�Q�那么调用：
PackageManager.setComponentEnabledSetting(widgetComponentName�Q�PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
PackageManager.DONT_KILL_APP);

但是问题是，调用�q�个�Ҏ(gu��)��disable掉这个widget后，发现必须把设备重启之后才能生�?..
�l�过google�Q�发现问题出在com.android.server.AppWidgetService.java�?br />原来开机后�Q�SystemServer会调用AppWidgetService的systemReady()�Ҏ(gu��)��Q�这个方法通过PackageManager查询所有的widget receiver�l��g�Q�保存到mInstalledProviders变量列表中，�q�持久化widget信息�?data/system/appwidgets.xml中�?br />而在Launcher上长按添加widget时的那个widget列表信息也是通过AppWidgetService取得mInstalledProviders列表�?br />问题在于我们通过PackageManager.setComponentEnabledSetting�Q�）��用掉某个widget后，packagemanager��实��这个组件disable了，但是AppWidgetService却没有去从packagemanager reload widget信息�Q�这��导致了mInstalledProviders中保存的widget信息�q�是开机时load�q�来的那些信息，�q�没有与pm�q�行同步。直��C��一�ơ开��用systemReady重新加蝲widget信息才会��h��q�个列表�?br />
参考：
Dynamically enabling or disabling a widget with PackageManager.setComponentEnabledSetting does not work
http://code.google.com/p/android/issues/detail?id=6533

http://blog.csdn.net/yinlijun2004/article/details/6136108

calvin 2011-12-27 14:14 发表评论

Activity的onSaveInstanceState调用时机

calvin — Tue, 22 Nov 2011 09:56:00 GMT

http://ice-k.iteye.com/blog/1018956

Activity的生命周期里�q�没有提到onSaveInstanceState的触发，�q�个函数提供了�ؓ我们在某些情况下保存Activity信息的机会，但需要注意的是这个函��C��是什么时候都会被调用的，官方文档解释的比较清楚，�Ҏ(gu��)��
��译一下�?
原文出处�Q�android-sdk-windows-1.5_r3/docs/reference/android/app/Activity.html#onSaveInstanceState(android.os.Bundle)
protected void onSaveInstanceState (Bundle outState)
       Called to retrieve per-instance state from an activity before being killed so that the state can be restored in onCreate(Bundle) or onRestoreInstanceState(Bundle) (the Bundle populated by this method will be passed to both). This method is called before an activity may be killed so that when it comes back some time in the future it can restore its state. For example, if activity B is launched in front of activity A, and at some point activity A is killed to reclaim resources, activity A will have a chance to save the current state of its user interface via this method so that when the user returns to activity A, the state of the user interface can be restored via onCreate(Bundle) or onRestoreInstanceState(Bundle).

    在activity被杀掉之前调用保存每个实例的状�?以保证该状态可以在onCreate(Bundle)或�? onRestoreInstanceState(Bundle) (传入的Bundle参数是由onSaveInstanceState��装好的)中恢复。这个方法在一个activity被杀��d��调用�Q�当�? activity在将来某个时��d��来时可以恢复其先前状态。例如，如果activity B启用后位于activity A的前端，在某个时刻activity A因�ؓ�pȝ��回收资源的问题要被杀掉，A通过onSaveInstanceState��有��Z��保存其用��L(f��ng)��面状态，使得��来用户�q�回到activity A时能通过onCreate(Bundle)或者onRestoreInstanceState(Bundle)恢复界面的状态�?

    Do not confuse this method with activity lifecycle callbacks such as onPause(), which is always called when an activity is being placed in the background or on its way to destruction, or onStop() which is called before destruction. One example of when onPause() and onStop() is called and not this method is when a user navigates back from activity B to activity A: there is no need to call onSaveInstanceState(Bundle) on B because that particular instance will never be restored, so the system avoids calling it. An example when onPause() is called and not onSaveInstanceState(Bundle) is when activity B is launched in front of activity A: the system may avoid calling onSaveInstanceState(Bundle) on activity A if it isn't killed during the lifetime of B since the state of the user interface of A will stay intact.

    不要��这个方法和activity生命周期回调如onPause()或onStop()搞�؜淆了�Q�onPause()在activtiy被放�|�到背景或�? 自行销毁时��M��被调用，onStop()在activity被销毁时被调用。一个会调用onPause()和onStop()�Q�但不触�? onSaveInstanceState的例子是当用户从activity B�q�回到activity A�Ӟ��没有必要调用B的onSaveInstanceState(Bundle)�Q�此时的B实例永远不会被恢复，因此�pȝ��会避免调用它。一个调�? onPause()但不调用onSaveInstanceState的例子是当activity B启动�q�处在activity A的前端：如果在B的整个生命周期里A的用��L(f��ng)��面状态都没有被破坏的话，�pȝ��是不会调用activity A的onSaveInstanceState(Bundle)的�?

    The default implementation takes care of most of the UI per-instance state for you by calling onSaveInstanceState() on each view in the hierarchy that has an id, and by saving the id of the currently focused view (all of which is restored by the default implementation of onRestoreInstanceState(Bundle)). If you override this method to save additional information not captured by each individual view, you will likely want to call through to the default implementation, otherwise be prepared to save all of the state of each view yourself. If called, this method will occur before onStop(). There are no guarantees about whether it will occur before or after onPause().

      默认的实现负责了大部分UI实例状�?的保�?�Q�采用的方式是调用UI层上每个拥有id的view的onSaveInstanceState() �Q��ƈ且保存当前获得焦点的view的id(所有保存的状态信息都会在默认的onRestoreInstanceState(Bundle)实现中恢�?�? 如果你覆写这个方法来保存额外的没有被各个view保存的信息，你可能想要在默认实现�q�程中调用或者自�׃��存每个视囄��所有状态。如果被调用�Q�这个方法会在onStop()前被触发�Q�但�pȝ��q�不保证是否在onPause()之前或者之后触发�?

很多不明白Activity�c�M��包含的onSaveInstanceState和onRestoreInstanceState有什么用�Q�首先声明下使用�q�两个方法时一定要注意情况和了解Activity的生命周期，否则有的时候�? onSaveInstanceState和onRestoreInstanceState 可能不会被触发，虽然他们都是Activity的重写方法。（�?Android开发网�Q?

他们比较常用到的地方�? Sensor、Land和Port布局的自动切换，�q�去Android开发网曄��说过解决横屏和竖屏切换带来的数据被置�I�或者说onCreate被重复调用问题，其实Android提供的onSaveInstanceState�Ҏ(gu��)��可以保存当前的窗口状态在卛_��布局切换前或当前Activity被推入历�? 栈，其实布局切换也调用过onPause所以被推入Activity的history stack�Q�如果我们的Activity在后台没有因��行内存吃紧被清理�Q�则切换回时会触发onRestoreInstanceState�Ҏ(gu��)��?

�q�两个方法中参数均�ؓBundle�Q�可以存攄��?SharedPreferences 的数据，所以��用它们作为当前窗口的状态保存是比较合适的。实际��用代�?
@Override
protected void onSaveInstanceState(Bundle outState){
            outState.putString("lastPath", "/sdcard/android123/cwj/test");
}

@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);

String cwjString = savedInstanceState.getString("lastPath");
}

onSaveInstanceState和onRestoreInstanceState触发的时�?
已有 199 �ơ阅�?2011-3-10 10:32 |个�h分类:Android|关键�?onSaveInstanceState onRestoreInstanceState
先看Application Fundamentals上的一�D�话�Q?
Android calls onSaveInstanceState() before the activity becomes vulnerable to being destroyed by the system, but does not bother calling it when the instance is actually being destroyed by a user action (such as pressing the BACK key)
从这句话可以知道�Q�当某个activity变得“容易”被�pȝ��销毁时�Q�该activity的onSaveInstanceState��׃��被执行，除非该activity是被用户��d��销毁的�Q�例如当用户按BACK键的时候�?
注意上面的双引号�Q�何为“容易”？�a�下之意就是该activity�q�没有被销毁，而仅仅是一�U�可能性。这�U�可能性有哪些�Q�通过重写一�? activity的所有生命周期的onXXX�Ҏ(gu��)��Q�包括onSaveInstanceState和onRestoreInstanceState�Ҏ(gu��)��Q�我们可以清楚地知道当某个activity�Q�假定�ؓactivity A�Q�显�C�在当前task的最上层�Ӟ��其onSaveInstanceState�Ҏ(gu��)��会在什么时候被执行�Q�有�q�么几种情况�Q?
1、当用户按下HOME键时。这是显而易见的�Q�系�l�不知道你按下HOME后要�q�行多少其他的程序，自然也不知道activity A是否会被销毁，故系�l�会调用onSaveInstanceState�Q�让用户有机会保存某些非�怹�性的数据。以下几�U�情�늚�分析都遵循该原则
2、长按HOME键，选择�q�行其他的程序时�?
3、按下电(sh��)源按键（关闭屏幕昄��Q�时�?
4、从activity A中启动一个新的activity时�?
5、屏�q�方向切换时�Q�例如从竖屏切换到横屏时。在屏幕切换之前�Q�系�l�会销毁activity A�Q�在屏幕切换之后�pȝ��又会自动地创建activity A�Q�所以onSaveInstanceState一定会被执�?
总而言之，onSaveInstanceState的调用遵循一个重要原则，卛_��pȝ��“未�l�你许可”时销毁了你的activity�Q�则 onSaveInstanceState会被�pȝ��调用�Q�这是系�l�的责�Q�Q�因为它必须要提供一个机会让你保存你的数据（当然你不保存那就随便你了�Q��?
至于onRestoreInstanceState�Ҏ(gu��)��Q�需要注意的是，onSaveInstanceState�Ҏ(gu��)��? onRestoreInstanceState�Ҏ(gu��)��“不一定”是成对的被调用的，onRestoreInstanceState被调用的前提是，activity A“确实”被�pȝ��销毁了�Q�而如果仅仅是停留在有�q�种可能性的情况下，则该�Ҏ(gu��)��不会被调用，例如�Q�当正在昄��activity A的时候，用户按下HOME键回��C��界面�Q�然后用��L(f��ng)��接着又返回到activity A�Q�这�U�情况下activity A一般不会因为内存的原因被系�l�销毁，故activity A的onRestoreInstanceState�Ҏ(gu��)��不会被执�?
另外�Q�onRestoreInstanceState的bundle参数也会传递到onCreate�Ҏ(gu��)��中，你也可以选择在onCreate�Ҏ(gu��)��中做数据�q�原

calvin 2011-11-22 17:56 发表评论

利用javap生成�Ҏ(gu��)��{�֐�

calvin — Mon, 24 Oct 2011 08:04:00 GMT

使用JNI在native内调用java�Ҏ(gu��)��Ӟ��需要知道java�Ҏ(gu��)��的方法签名，利用javap工具可以方便的生成签名。由于java�Ҏ(gu��)��{�֐�在jni层的表示�Ҏ(gu��)��的复杂性，利用�q�个工具生成�{�֐�信息可以避免人工分析带来的错误�?br />如：

1 package com.demo;
2
3 public class SigTest {
4
5     public static final String name = null;
6
7     public int getName(int[] data,long index) {
8         return 0;
9     }
10 }
11

[calvin@calvin-desktop /tmp 15:59:50 ]
$ javac SigTest.java
[calvin@calvin-desktop /tmp 15:59:57 ]
$ javap -s -p -classpath . SigTest
Compiled from "SigTest.java"
public class com.demo.SigTest extends java.lang.Object{
public static final java.lang.String name;
Signature: Ljava/lang/String;
public com.demo.SigTest();
Signature: ()V
public int getName(int[], long);
Signature: ([IJ)I
static {};
Signature: ()V
}

-s表示打印�{�֐�信息
-p表示打印所有函数和成员的签名信息，默认只打印public的签名信息�?br />
注意�Q?br />�_�体部分�?class文�g的文件名�Q�不�?class后缀�Q�否则提�C?br />ERROR:Could not find SigTest.class.

calvin 2011-10-24 16:04 发表评论

[转]The Android boot process from power on

calvin — Wed, 07 Sep 2011 02:53:00 GMT

[First written by Steve Guo, please keep the mark if forwarding.].

init is the first process after kernel started. The corresponding source code lies in: device/system/init. It does the following tasks step by step:

1.       Initialize log system.

2.       Parse /init.rc and /init.%hardware%.rc.

3.       Execute early-init action in the two files parsed in step 2.

4.       Device specific initialize. For example, make all device node in /dev and download firmwares.

5.       Initialize property system. Actually the property system is working as a share memory. Logically it looks like a registry under Windows system.

6.       Execute init action in the two files parsed in step 2.

7.       Start property service.

8.       Execute early-boot and boot actions in the two files parsed in step 2.

9.       Execute property action in the two files parsed in step 2.

10.   Enter into an indefinite loop to wait for device/property set/child process exit events. For example, if an SD card is plugined, init will receive a device add event, so it can make node for the device. Most of the important process is forked in init, so if any of them crashed, init will receive a SIGCHLD then translate it into a child process exit event, so in the loop init can handle the process exit event and execute the commands defined in *.rc(it will run command onrestart).

The .rc file is a script file defined by Android. The default is device/system/rootdir/init.rc. We can take a loot at the file format(device/system/init/readme.txt is a good overall introduction of the script). Basically the script file contains actions and services.

Actions

-------

Actions are named sequences of commands. Actions have a trigger which is used to determine when the action should occur. When an event occurs which matches an action's trigger, that action is added to the tail of a to-be-executed queue (unless it is already on the queue).

Each action in the queue is dequeued in sequence and each command in that action is executed in sequence. Init handles other activities (device creation/destruction, property setting, process restarting) "between" the execution of the commands in activities.

Actions take the form of:

on







...

Services

--------

Services are programs which init launches and (optionally) restarts when they exit. Services take the form of:

service [ ]*

Compile CyanogenMod (Linux) for HTC Desire

calvin — Tue, 06 Sep 2011 10:12:00 GMT

参照guide�Q?br />http://wiki.cyanogenmod.com/wiki/HTC_Desire_(GSM):_Compile_CyanogenMod_(Linux)

出现如下问题�Q?br />
1.repo init时报错：
......
object 30d452905f166b316152f236422f85c8aa75a2d0
type commit
tag v1.7.5
tagger Shawn O. Pearce 1307663540 -0700

repo 1.7.5

gpg: Signature made Fri 10 Jun 2011 07:52:20 AM CST using DSA key ID 920F5C65
gpg: Can't check signature: public key not found
error: could not verify the tag 'v1.7.5'

出错原因是曾使用repo sync从其它库sync�q�代码，删掉~/.repoconfig卛_��Q?br />$ rm -rf ~/.repoconfig
$ ./repo init -u git://github.com/CyanogenMod/android.git -b gingerbread
gpg: keyring `/home/calvin/.repoconfig/gnupg/secring.gpg' created
gpg: keyring `/home/calvin/.repoconfig/gnupg/pubring.gpg' created
gpg: /home/calvin/.repoconfig/gnupg/trustdb.gpg: trustdb created
gpg: key 920F5C65: public key "Repo Maintainer " imported
gpg: Total number processed: 1
gpg:               imported: 1

Getting repo ...
   from http://android.git.kernel.org/tools/repo.git
。。。�?br />

2.repo sync时报错：
。。。。�?br />Fetching projects:   1% (3/285)
Initializing project platform/bootable/bootloader/legacy ...
android.git.kernel.org[0: 130.239.17.13]: errno=Connection refused
android.git.kernel.org[0: 149.20.4.77]: errno=Connection timed out
android.git.kernel.org[0: 199.6.1.173]: errno=Connection refused
android.git.kernel.org[0: 2001:4f8:8:10:1972:112:1:0]: errno=Network is unreachable
android.git.kernel.org[0: 2001:500:60:10:1972:112:1:0]: errno=Network is unreachable
android.git.kernel.org[0: 2001:6b0:e:4017:1972:112:1:0]: errno=Network is unreachable
android.git.kernel.org[0: 2001:4f8:1:10:1972:112:1:0]: errno=Network is unreachable
fatal: unable to connect a socket (Network is unreachable)
error: Cannot fetch platform/bootable/bootloader/legacy

�q�接服务器时的问题，解决�Q?br />修改.repo/manifest.xml�?br />            fetch="git://android.git.kernel.org/"
           review="review.source.android.com" />
�?br />            fetch="http://android.git.kernel.org/"
           review="review.source.android.com" />

calvin 2011-09-06 18:12 发表评论

calvin — Mon, 29 Aug 2011 06:16:00 GMT

在AndroidManifest.xml中声�?br />android:sharedUserId="android.uid.system"
后，该应用程序将没有权限��d��SD卡�?br />
Processes that continue holding open fds on the sdcard a little after it is
requested to be unmounted will be killed so that it can unmount.

We don't want the system process to be able to access the sdcard to avoid
these kinds of issues (and just general security cleanliness), so that it
does not have permission to access it.

http://groups.google.com/group/android-porting/browse_thread/thread/c6af65d7ddd5eff3
http://stackoverflow.com/questions/5617797/android-shared-user-id-and-reading-writing-a-file
http://stackoverflow.com/questions/6679011/it-cant-access-the-sdcard-after-setting-android-uid-system-in-my-application
http://www.eoeandroid.com/forum.php?mod=viewthread&tid=63314&page=1#pid636737

calvin 2011-08-29 14:16 发表评论

Android monkey & jni相关

calvin — Fri, 27 May 2011 07:08:00 GMT

首先�Q�android�q�_��应用�E�序可能产生以下四种crash�Q?br />App层：
Force close crash
ANR crash
Native层：
Tombstone crash
Kernel层：
Kernel panic
比较隑֮�位，可以查看/proc/last_kmsg来辅助定位�?br />
最�q�需要通过monkey工具��试Tombstone�c�d��的crash�Q�抓取log�q�分析。通过monkey��试�Q�如果要抓取native�c�d��的crash�Q�需要加�?-monitor-native-crash参数�Q?br />
seed=$(date +%Y%m%d%H%m%S)
monkey -s $seed --pkg-whitelist-file ${your-package-list} --monitor-native-crashes --kill-process-after-error -v -v -v 2000000000

�q�样�Q�monkey在跑出crash后，�?data/system/dropbox �?/data/tombstones目录下会生成相关日志�Q�moneky会停止发送事件流�q��出测�?值得注意的是�Q?data/tombstones文�g夹下只会保存10个日志，��过10个后�Q�最早创建的会被替换。而monkey是通过监视�q�个文�g夹下的文件数量变化来判断是否有tombtone�c�d��的crash产生的。因此，�?data/tombstones文�g夹下��过10个文件后�Q�如果再有tombstone crash产生的话�Q�monkey是不能检��到的，它会�l�箋发送事件流。�ؓ了避免这个问题，可以在每�ơ运行monkey之前先清�I�Z��下这个文件夹�?br />
另外�Q�在settings.db中的secure表中有三个字�D�：dropbox:data_app_wtf,dropbox:data_app_anr,dropbox:data_app_crash。如果设�|��ؓenabled�Q�每当有app crash之后�Q�在/data/system/dropbox�q�个文�g夹下都会产生相关的日志信息，�q�对于分析调试问题都是第一手的信息�?br />
如何刉��tombstone�c�d��的crash�Q?br />�q�需要通过jni调用一个native的so文�g�Q�在本地代码中抛出异常即可�?br />可以�~�写如下代码tombstone_gen.cpp:
int main(int argc, char **argv) {
int *p=0;
*p=1; //will seg fault
return 0;
}
参照development/samples/SimpleJNI的示例，�q�行build出的apk卛_��?br />
关于jni调用�Q�也有几个问题：
1.FindClass,RegisterNatives�{�找不到�Q?br />target thumb C: libtombstonec <= development/samples/AndroidDemos/jni/tombstone_gen.c
development/samples/AndroidDemos/jni/tombstone_gen.c: In function 'registerNativeMethods':
development/samples/AndroidDemos/jni/tombstone_gen.c:48: error: request for member 'FindClass' in something not a structure or union
development/samples/AndroidDemos/jni/tombstone_gen.c:53: error: request for member 'RegisterNatives' in something not a structure or union
development/samples/AndroidDemos/jni/tombstone_gen.c: In function 'JNI_OnLoad':
development/samples/AndroidDemos/jni/tombstone_gen.c:97: error: request for member 'GetEnv' in something not a structure or union
make: *** [out/target/product/generic/obj/SHARED_LIBRARIES/libtombstonec_intermediates/tombstone_gen.o] Error 1

问题原因在于�Q?br />如果是C�E�序�Q�要�?(*env)->
如果是C++要用 env->
因此有两�U�解��x��法：
1、将 (*env)-> 改�ؓ env->
2、将c文�g改�ؓcpp文�g�Q�改为c++的方式编译�?br />
2、运行时异常java.lang.UnsatisfiedLinkError
tombstone_gen.cpp�?br />static const char *classPathName = "com/android/demo/AndroidDemos";
�c�d��有误�Q�导致类链接错误�?br />
最后，关于jni中JNINativeMethod相关解释�Q?br />http://hi.baidu.com/zhlg_hzh/blog/item/f0d782081f2f45d963d986f5.html

calvin 2011-05-27 15:08 发表评论

在android工程中导入layoutlib.jar使用internal api

calvin — Thu, 28 Apr 2011 03:39:00 GMT

在android-sdk-linux_x86/platforms/android-10/data/layoutlib.jar中包含了source中internal的api�Q�在eclipse中导入这个jar包就可以使用internal的api了�?br /> 导入�Ҏ(gu��)��Q?br /> 1. Right-click the project in Eclipse and select "Build Path -> Add Libraries...".
2. Select User Library from the list and click Next.
3. Click the "User Libraries..." button.
4. Click "New..." in the User Libraries dialog.
5. Give the user library a name and select the System library checkbox and click OK.
6. Highlight the newly added user library in the list and click the "Add JARs..." button and add the desired jar files.
7. Click OK on the User Libraries dialog.
8. Make sure the new user library is checked in the Add Library dialog and

不以�q�种方式��d��会出现DEX error�Q�切�?br />

calvin 2011-04-28 11:39 发表评论

Eclipse 导入gingerbread源代码build path错误

calvin — Thu, 21 Apr 2011 08:29:00 GMT

在eclipse中导入gingerbread源代码后出现如下build path错误�Q?br />
Project 'gingerbread' is missing required library: 'out/target/common/obj/JAVA_LIBRARIES/google-common_intermediates/javalib.jar'
Project 'gingerbread' is missing required library: 'out/target/common/obj/JAVA_LIBRARIES/gsf-client_intermediates/javalib.jar'

解决�Q?br /> 删除.classpath中的�q�两行�\�?br />

��d��

或�?br /> https://groups.google.com/group/android-platform/browse_thread/thread/5c86d1f1929eed3c?pli=1
http://topic.csdn.net/u/20110406/19/5cc32204-b45e-4427-a3ea-eacd83fede13.html

calvin 2011-04-21 16:29 发表评论

使用git下蝲android源码

calvin — Wed, 02 Mar 2011 17:39:00 GMT

1、Git的安�?/strong>

sudo apt-get install git-core

2、安装Repo
2.1首先��保在当前用��L(f��ng)��ȝ��录下创徏一个~/bin目录�Q�如果没有的话）�Q?/p>
2.2然后把它(~/bin)加到PATH环境变量�?

echo “export PATH=$PATH:~/bin” > ~/.bashrc

source ~/.bashrc
2.3下蝲repo

打开http://android.git.kernel.org/repo�Q�把该网��保存�ؓ ~/bin/repo

�l�repo可执行权�?br style="line-height: 22px;" /> chmod a+x ~/bin/repo

3�Q�设�|�git代理参考，见我的一��文�?/strong>

http://blog.chinaunix.net/u3/93670/showart_2084139.html

4、初始化版本�?/strong>

4.1修改repo内容

�?#8220;git:”�Ҏ(gu��)��“http:”

4.2新徏~/android目录�Q�进��M��后用repo init命��o卛_��。只初始�?.0版（eclair�Q?/p>
repo init -u http: //android.git.kernel.org/platform/manifest.git -b eclair

最后会看到 repo initialized in /android�q�样的提�C�，��p��明本地的版本库已�l�初始化完毕�Q��ƈ且包含了当前最新的sourcecode�?/p>
通常情况下会出现error提示�Q�如果是以前没有创徏�q�repo账户的话�Q�，�q�个不要紧，忽略掉它好了�?br style="line-height: 22px;" />
配置repo账户
git config --global user.email "[email=xxxxx@xxxxxxx]xxxxx@xxxxxxx[/email]"
git config --global user.name "xxxxxx"

5、同步版本库
5.1修改.repo/manifest.xml

�?#8220;git:”�Ҏ(gu��)��“http:”

5.2同步�Q�其实是正式下蝲�Q�前面init只是下蝲了具体的路径和依赖文�Ӟ��

repo sync

另一�U�情冉|�� Q?span style="line-height: 21px; font-weight: bold;">只下载某一个项�?/span> �?/p>
我们只需要某一个project的代码，比如kernel/common�Q�就不需要repo了，直接用Git卛_��?br style="line-height: 22px;" /> git clone git://android.git.kernel.org/kernel/common.git
�q�也需要不��的旉��Q�因为它会把整个Linux Kernel的代码复制下来�?/p>
如果需要某个branch的代码，用git checkout卛_��。比如我们刚刚拿了kernel/common.get的代码，那就先进入到common目录�Q�然后用下面的命令：
git checkout origin/android-goldfish-2.6.27 -b goldfish
�q�样我们��在本地建立了一个名为goldfish的android-goldfish-2.6.27分支�Q�代码则已经与android-goldgish-2.6.27同步。我们可以通过git branch来列出本地的所有分支�?/p>

calvin 2011-03-03 01:39 发表评论

SurfaceView与View

calvin — Wed, 08 Dec 2010 03:20:00 GMT

如果你的游戏不吃CPU�Q�用View��比较好�Q�符合标准Android操作方式�Q�由�pȝ��军_��h��surface的时机�?br /> 但如果很不幸的，你做不到不让你的�E�序吃CPU�Q�你��只好��用SurfaceView来强制刷新surface了，不然�pȝ��的UI�q�程很可能抢不过你那些吃CPU的线�E��?br />
当然其实不止�q�两�U�方法来��h��Surface的，�q�两�U�只是纯java应用比较常见的方法�?br />

SurfaceView和View最本质的区别在于，surfaceView是在一个新��L(f��ng)��单独�U�程中可以重新绘制画面而View必须在UI的主�U�程中更新画面�?br /> 那么在UI的主�U�程中更新画�?可能会引发问题，比如你更新画面的旉��q�长�Q�那么你的主UI�U�程会被你正在画的函数阻塞。那么将无法响应按键�Q�触屏等消息�?br />
当��用surfaceView �׃��是在新的�U�程中更新画面所以不会阻塞你的UI�ȝ��E�。但�q�也带来了另外一个问题，��是事�g同步。比如你触屏了一下，你需要surfaceView中thread处理�Q�一般就需要有一个event queue的设计来保存touch event�Q�这会稍�E�复杂一点，因�ؓ涉及到线�E�同步�?br />
所以基于以上，�Ҏ(gu��)��游戏特点�Q�一般分成两�c�R�?br />
1 被动更新画面的。比如棋�c�，�q�种用view��好了。因为画面的更新是依赖于 onTouch 来更斎ͼ�可以直接使用 invalidate�?因�ؓ�q�种情况下，�q�一�ơTouch和下一�ơ的Touch需要的旉��比较长些�Q�不会��生媄响�?br />
2 ��d��更新。比如一个�h在一直跑动。这��需要一个单独的thread不停的重�l��h的状态，避免��d��main UI thread。所以显然view不合适，需要surfaceView来控制�?br />

calvin 2010-12-08 11:20 发表评论

android bluetooth

calvin — Mon, 06 Dec 2010 06:48:00 GMT
http://blog.csdn.net/dyufei/archive/2010/08/16/5815719.aspx

http://blog.csdn.net/dyufei/archive/2010/08/27/5844353.aspx

http://www.tkk7.com/Files/lihao336/android/android-Bluetooth.pdf

calvin 2010-12-06 14:48 发表评论

Talking about Android process

calvin — Mon, 29 Nov 2010 08:14:00 GMT

[First written by Steve Guo, please keep the mark if forwarding.]

In this topic you will learn some information about Android process management. First let’s take a look at the launched processes during Android booting.

USER PID PPID VSIZE RSS WCHAN PC NAME

root 1 0 264 176 c00acc6c 0000c36c S /init

root 28 1 724 308 c0051354 afe0c4cc S /system/bin/sh

system 30 1 796 248 c026516c afe0b74c S /system/bin/servicemanager

root 31 1 1824 316 ffffffff afe0b50c S /system/bin/mountd

root 32 1 652 248 c02976e0 afe0c0bc S /system/bin/debuggerd

radio 33 1 5344 664 ffffffff afe0bdbc S /system/bin/rild

root 34 1 71028 18828 c00ad308 afe0b874 S zygote

media 37 1 16812 3456 ffffffff afe0b74c S /system/bin/mediaserver

root 39 1 788 288 c02f9ae4 afe0b50c S /system/bin/installd

system 86 34 187756 21836 ffffffff afe0b74c S system_server

radio 118 34 103476 13896 ffffffff afe0c824 S com.android.phone

app_4 124 34 117848 19248 ffffffff afe0c824 S android.process.acore

app_5 139 34 98672 11516 ffffffff afe0c824 S com.android.mms

app_3 151 34 92096 10976 ffffffff afe0c824 S com.android.alarmclock

app_6 161 34 94436 12616 ffffffff afe0c824 S com.android.calendar

app_9 173 34 93248 11728 ffffffff afe0c824 S android.process.media

app_15 182 34 91848 9764 ffffffff afe0c824 S com.android.voicedialer

app_16 190 34 94524 10812 ffffffff afe0c824 S android.process.im

They can be divided into three kinds.

Root Process

init is the first process after kernel booting. The major task it performs:

l Parser and execute init.rc and init.%hardware%.rc

l Automatically generate device node under /dev

l Start log and property service

l Monitor for device, property set and child process exit events

Native Application Process

According to init.rc, init will fork the following native application process.

console: star a shell.

servicemanager: start binder IPC service manager.

mountd: mount all fs defined in /system/etc/mountd.conf if started, receive commands through local socket to mount any fs.

debuggerd: start debug system.

rild: start radio interface layer daemon.

zygote: start Android Java VM Runtime and start system server. It’s the most important process.

mediaserver: start AudioFlinger, MediaPlayerService and CameraService.

installd: start install package daemon.

JAVA Application Process

Every JAVA application process is forked from zygote process. system_server is a special JAVA process, which is directly forked from zygote.. Other JAVA process is created from ActivityManagerService(run in system_server process) like this.

int pid = Process.start("android.app.ActivityThread",

mSimpleProcessManagement ? app.processName : null, uid, uid,

gids, ((app.info.flags&ApplicationInfo.FLAG_DEBUGGABLE) != 0), null);

While Process.java use UNIX domain socket to communicate with zygote. So the overall picture is shown as following.

System Server

It’s the first JAVA application launched by zygote. It starts the core Android services, e.g. ActivityManager, WindowManager, PackageManager etc. It’s the Android core engine.

Persistent Application

During booting, ActivityManagerService.systemReady will start all persistent applications.

List apps = ActivityThread.getPackageManager().

getPersistentApplications(PackageManager.GET_SHARED_LIBRARY_FILES);

if (apps != null) {

int N = apps.size();

int i;

for (i=0; i

ApplicationInfo info

= (ApplicationInfo)apps.get(i);

if (info != null &&

!info.packageName.equals("android")) {

addAppLocked(info);

}

}

}

Currently only Phone application is registered as a persistent app in AndroidManifest.xml like this.

android:persistent="true"

android:label="@string/dialerIconLabel"

android:icon="@drawable/ic_launcher_phone">

So during booting, only phone application is automatically launched. It’s the “com.android.phone” process.

The First Activity

The first activity is launched by senting Intent.CATEGORY_HOME intent from ActivityManagerService.

Intent intent = new Intent(

mTopAction,

mTopData != null ? Uri.parse(mTopData) : null);

intent.setComponent(mTopComponent);

if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {

intent.addCategory(Intent.CATEGORY_HOME);

}

ActivityInfo aInfo =

intent.resolveActivityInfo(mContext.getPackageManager(),

PackageManager.GET_SHARED_LIBRARY_FILES);

if (aInfo != null) {

intent.setComponent(new ComponentName(

aInfo.applicationInfo.packageName, aInfo.name));

// Don't do this if the home app is currently being

// instrumented.

ProcessRecord app = getProcessRecordLocked(aInfo.processName,

aInfo.applicationInfo.uid);

if (app == null || app.instrumentationClass == null) {

intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK);

startActivityLocked(null, intent, null, null, 0, aInfo,

null, null, 0, 0, 0, false);

}

}

It’s the “android.process.acore” process. (The process name is defined in AndroidManifest.xml)

Auto-launched Application After Booting

When activity idle is detected in ActivityManagerService, it will broadcast ACTION_BOOT_COMPLETED intent at the first time.

if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {

// Tell anyone interested that we are done booting!

synchronized (this) {

broadcastIntentLocked(null, null,

new Intent(Intent.ACTION_BOOT_COMPLETED, null),

null, null, 0, null, null,

android.Manifest.permission.RECEIVE_BOOT_COMPLETED,

false, false, MY_PID, Process.SYSTEM_UID);

}

}

Currently, MMS, AlarmClock, Calendar, MediaProvider, VoiceDialer and IM have registered as a receiver for ACTION_BOOT_COMPLETED intent in their AndroidManifest.xml. So they will be automatically launched. (This explains the remained JAVA process.)

Email also registers as a receiver for ACTION_BOOT_COMPLETED intent in its AndroidManifest.xml, but it defines android:enable=”false”. So it won’t be launched.

android:enabled="false"

>

DownloadProvider also registers as a receiver for ACTION_BOOT_COMPLETED intent in its AndroidManifest.xml, but it defines android:exported=”false”. So it won’t be launched.

android:exported="false">

Behind the JAVA process

system_server is a special case. It calls ActivityThread.java’s systemMain static function, which creates an instance of ActivityThread. ActivityThread then creates an instance of ApplicationThread, Application and ApplicationContext.

Every other JAVA process works in a different way. It’s controlled by system_server while forked by zygote. When any JAVA process other than system_server is forked from zygote, it automatically calls ActivityThread.java’s main static function(See Process.java and the following code snippet).

try {

ZygoteInit.invokeStaticMain(cloader, className, mainArgs);

} catch (RuntimeException ex) {

logAndPrintError (newStderr, "Error starting. ", ex);

}

The ActivityThread.java’s main function creates an instance of ActivityThread. ActivityThread then creates an instance of ApplicationThread. The ApplicationThread will work as an IBinder object to interact with ActivityManagerService in system_server. The new process does nothting at this time other than waiting IPC call from system_server. The Application and ApplicationContext object won’t be created at this time. Actually it’s deferred to when the process really works, eg. start an activity, receive intent or start a service.

For example, when start an activity, ActivityManagerService know which process the to-be-launched activity should run in, so it will RPC call ApplicationThread’s scheduleLaunchActivity to launch a new activity in that process. ApplicationThread then post a message to let ActivityThread know it needs to start an activity. ActivityThread then creates Application and ApplicationContext object. After that, it calls Instrumentation, then Instrumentation finally calls JAVA dalvik VM to really create an activity JAVA object.

原文地址 http://letsgoustc.spaces.live.com/?_c11_BlogPart_BlogPart=blogview&_c=BlogPart&partqs=cat%3DGoogle%2

calvin 2010-11-29 16:14 发表评论

handler与多�U�程消息处理

calvin — Mon, 29 Nov 2010 06:55:00 GMT
转蝲地址�Q�http://blog.csdn.net/jinlking/archive/2009/07/09/4333456.aspx

在Android下面也有多线�E�的概念�Q�在C/C++中，子线�E�可以是一个函敎ͼ�一般都是一个带有��@环的函数�Q�来处理某些数据�Q�优先线�E�只是一个复杂的�q�算�q�程�Q�所以可能不需要while循环�Q�运��完成，函数�l�束�Q�线�E�就销毁。对于那些需要控制的�U�程�Q�一般我们都是和互斥锁相互关联，从而来控制�U�程的进度，一般我们创建子�U�程�Q�一�U�线�E�是很常见的�Q�那��是带有消息循环的线�E��?br />
消息循环是一个很有用的线�E�方式，曄��自己用C在Linux下面实现一个消息��@环的机制�Q�往消息队列里添加数据，然后异步的等待消息的�q�回。当消息队列为空的时候就会挂��L(f��ng)��E�，�{�待新的消息的加入。这是一个很通用的机制�?br />
在Android�Q�这里的�U�程分�ؓ有消息��@环的�U�程和没有消息��@环的�U�程�Q�有消息循环的线�E�一般都会有一个Looper�Q�这个是android的新概念。我们的�ȝ��E�（UI�U�程�Q�就是一个消息��@环的�U�程。针对这�U�消息��@环的机制�Q�我们引入一个新的机制Handler�Q�我们有消息循环�Q�就要往消息循环里面发送相应的消息�Q�自定义消息一般都会有自己对应的处理，消息的发送和清除�Q�消息的的处理，把这些都��装在Handle里面�Q�注意Handle只是针对�?些有Looper的线�E�，不管是UI�U�程�q�是子线�E�，只要你有Looper�Q�我��可以往你的消息队列里面��d��东西�Q��ƈ做相应的处理�?br />
但是�q�里�q�有一点，��是只要是关于UI相关的东西，��׃��能放在子�U�程中，因�ؓ子线�E�是不能操作UI的，只能�q�行数据、系�l�等其他非UI的操作�?br />
那么什么情况下面我们的子线�E�才能看做是一个有Looper的线�E�呢�Q?strong>我们如何得到它Looper的句柄呢�Q?/strong>

Looper.myLooper();获得当前的Looper

Looper.getMainLooper () 获得UI�U�程的Lopper

我们看看Handle的初始化函数�Q�如果没有参敎ͼ�那么他就默认使用的是当前的Looper�Q�如果有Looper参数�Q�就是用对应的线�E�的Looper�?br />
如果一个线�E�中调用Looper.prepare()�Q�那么系�l�就会自动的��U�程建立一个消息队列，然后调用 Looper.loop();之后��p��入了消息循环�Q�这个之后就可以发消息、取消息、和处理消息。这个如何发送消息和如何处理消息可以在其他的�U�程中通过 Handle来做�Q�但前提是我们的Handle知道�q�个子线�E�的Looper�Q�但是你如果不是在子�U�程�q�行 Looper.myLooper()�Q�一般是得不到子�U�程的looper的�?br />
public void run() {
            synchronized (mLock) {
                Looper.prepare();
               //do something
            }
            Looper.loop();
        }

所以很多�h都是�q�样做的�Q�我直接在子�U�程中新建handle�Q�然后在子线�E�中发送消息，�q�样的话��失��M��我们多线�E�的意义了�?br />
1 class myThread extends Thread{
2
3              private EHandler mHandler ;
4
5              public void run() {
6
7                  Looper myLooper, mainLooper;
8
9                  myLooper = Looper.myLooper ();
10
11                 mainLooper = Looper.getMainLooper ();
12
13                 String obj;
14
15                 if (myLooper == null ){
16
17                          mHandler = new EHandler(mainLooper);
18
19                          obj = "current thread has no looper!" ;
20
21                 }
22
23                 else {
24
25                      mHandler = new EHandler(myLooper);
26
27                      obj = "This is from current thread." ;
28
29                 }
30
31                 mHandler .removeMessages(0);
32
33                 Message m = mHandler .obtainMessage(1, 1, 1, obj);
34
35                 mHandler .sendMessage(m);
36
37              }
38
39   }

可以让其他的�U�程来控制我们的handle�Q�可以把 private EHandler mHandler ;攑֜�外面�Q�这��h��们的发消息和处理消息都可以在外面来定义，�q�样增加�E�序代码的美观，�l�构更加清晰�?br />
对如��M��的Handle�Q�里面必��要重蝲一个函�?br />
public void handleMessage(Message msg)

�q�个函数��是我们的消息处理，如何处理�Q�这里完全取决于你，然后通过 obtainMessage�?sendMessage�{�来生成和发送消息， removeMessages(0)来清除消息队列。Google真是太智慧了�Q�这�U�框架的产生�Q�我们写代码更加��L��了�?br />
有的时候，我们的子�U�程惛_��改变UI了，�q�个时候千万不要再子线�E�中��M��改，获得UI�U�程的Looper�Q�然后发送消息即可�?br />
我们来看看高焕堂的代码：

// class ac01 extends Activity {

          // ………

              public void onClick(View v) {

                     switch (v.getId()){

                     case 101:

                                  t = new myThread();

                            t .start();

                          break ;

                     case 102:

                  finish();

                                break ;

                     }

           }

//------------------------------------------------------

class EHandler extends Handler {

                   public EHandler(Looper looper) {

                       super (looper);

                   }

                   @Override

                   public void handleMessage(Message msg) {

                      tv .setText((String)msg. obj );

               }

           }

//------------------------------------------------------

class myThread extends Thread{

             private EHandler mHandler ;

             public void run() {

                Looper myLooper, mainLooper;

                myLooper = Looper.myLooper ();

                mainLooper = Looper.getMainLooper ();

                String obj;

                if (myLooper == null ){

                        mHandler = new EHandler(mainLooper);

                        obj = "current thread has no looper!" ;

                }

                else {

                     mHandler = new EHandler(myLooper);

                     obj = "This is from current thread." ;

                }

                mHandler .removeMessages(0);

                Message m = mHandler .obtainMessage(1, 1, 1, obj);

                mHandler .sendMessage(m);

             }

}

}

完全是不知所云，一坨狗屎。我们来看，在上面的run里面

Looper myLooper, mainLooper;

myLooper = Looper.myLooper (); //很明显这个会�q�回�I�，因�ؓ你还没有 prepare�Q�不会返回Looper�?br />
mainLooper = Looper.getMainLooper ();

��大家在看Looper的时候不要看高焕堂的书，感觉他也不是很懂�Q�倒还把我搞糊涂了。讲了那么多�Q�完全是他自��q��理解�Q�他自己的理解很是复杂，关键的是把简单的问题复杂化，�q�且复杂之后的东西还是错的。我们看看Goole Music App的源代码�?br />
在MediaPlaybackActivity.java中，我们可以看一下再OnCreate中的有这��L(f��ng)��两句�Q?br />
        mAlbumArtWorker = new Worker("album art worker");
        mAlbumArtHandler = new AlbumArtHandler(mAlbumArtWorker.getLooper());

很明显这两句�Q�是构徏了一个子�U�程。�ƈ且这个子�U�程�q�是Looper的子�U�程�Q�这里很牛逼的使用�?mAlbumArtWorker.getLooper()�q�个函数�Q�因为我们知道，我们能够得到子线�E�的Looper的途径只有一个：��是在子�U�程中调�?Looper.myLooper ()�Q��ƈ且这个函数还要在我们perpare之后调用才能得到正确的Looper�Q�但是他�q�里用了一个这��L(f��ng)��什么东�?getLooper�Q�不知道它是如何实现的？

�q�里有一个大概的思�\�Q�我们在子线�E�的的prepare之后调用 myLooper ()�q�个�Ҏ(gu��)��Q�然后保存在一个成员变量中�Q�这个getLooper��p��回这个东西，但是�q�里会碰到多�U�程的一个很�H�出的问题，同步。我们在父线�E�中调用 mAlbumArtWorker.getLooper()�Q�但是想要这个返回正��的looper��必��要求我们的子线�E�运行了prepare�Q�但是这个东西实在子�U�程�q�行的，我们如何保证呢？

我们看Google是如何实现的�Q?br />

  private class Worker implements Runnable {
        private final Object mLock = new Object();
        private Looper mLooper;

        /**
         * Creates a worker thread with the given name. The thread
         * then runs a {@link android.os.Looper}.
         * @param name A name for the new thread

         */
        Worker(String name) {
            Thread t = new Thread(null, this, name);
            t.setPriority(Thread.MIN_PRIORITY);
            t.start();
            synchronized (mLock) {
                while (mLooper == null) {
                    try {
                        mLock.wait();
                    } catch (InterruptedException ex) {
                    }
                }
            }
        }

        public Looper getLooper() {
            return mLooper;
        }

        public void run() {
            synchronized (mLock) {
                Looper.prepare();
                mLooper = Looper.myLooper();
                mLock.notifyAll();
            }
            Looper.loop();
        }

        public void quit() {
            mLooper.quit();
        }
    }

我们知道�Q�一个线�E�类的构造函数是在主�U�程中完成的�Q�所以在我们�?Worker的构造函��C��我们创佳一个线�E�，然后让这个线�E�运行，�q�一�q�个�U�程的创建是指定一�?Runnabl�Q�这里就是我们的Worker本��n�Q�在�ȝ��E�调�?t.start();�Q�这后，我们子线�E�已�l�创建，�q�且开始执行work的run�Ҏ(gu��)��。然后下面的代码很艺术：

synchronized (mLock) {
                while (mLooper == null) {
                    try {
                        mLock.wait();
                    } catch (InterruptedException ex) {
                    }
                }
            }

我们开始等待我们的子线�E�给mLooper赋��|��如果不赋值我们就�l�箋�{�，然后我们的子�U�程在运行run�Ҏ(gu��)��之后�Q�在�l?mLooper赋��g��后，通知worker够着函数中的wait�Q�然后我们的构造函数才能完成，所以我们说�Q?br />
mAlbumArtWorker = new Worker("album art worker");

�q�句本��n��是��d��的，它创��Z��一个子�U�程�Q�开启了子线�E�，�q�且�{�待子线�E�给mLooper赋��|��赋值完成之后，�q�个函数才返回，�q�样才能保证我们的子�U�程的Looper的获取绝�Ҏ(gu��)��正确的，�q�个构思很有创意。值得借鉴�?br />
PS�Q?br /> 1、发送消息�ƈ不会��d��U�程�Q�而处理消息时会阻塞线�E�，�q�是因�ؓHandler 处理完一�?Message 对象才会接着��d��下面一个消息进行处理�?br /> Handler对于Message的处理不是�ƈ发的。一个Looper 只有处理完一条Message才会��d��下一条，所以消息的处理是阻塞�Ş式的�Q�如果在handler里做耗时的操作，则调用者线�E�会��d��。但是如�?strong>用不同的Looper则能辑ֈ��q�发的目�?/strong>。（http://windywindy.javaeye.com/blog/464185�Q?br />
2、Android提供了一个HandlerThread来实现�ƈ发处理message的目的，HandlerThread在实��C��与Music应用的Worker�cȝ��伹{�?br />
参考：

Android中的MessageQueue,Handler,Looper和Thread

android handler 多线�E�demo

Handler与线�E�的关系

图解 Android Handler �U�程消息机制

calvin 2010-11-29 14:55 发表评论

Android �H�口��理

calvin — Wed, 24 Nov 2010 10:28:00 GMT
Android �H�口��理
在整个控件树(w��i)的最��端�Q�是一个逻辑的树(w��i)��Ӟ��ViewParent�Q�在源码中的实现是ViewRoot�Q�ViewRoot extends Handler implements ViewParent�Q�。它是整个控件树(w��i)和W(xu��)indowManager之间的事件信息的��译者。WindowManager是Android中一个重要的服务。它?y��u)��用��L(f��ng)��操作�Q�翻译成为指令，发送给呈现在界面上的各个Window。Activity会将��的控件注册到WindowManager中，当用��L(f��ng)��是触��屏�q�或键盘的时候，W(xu��)indowManager��׃��通知刎ͼ�而当控�g有一些请求��生，也会�l�由ViewParent送回到WindowManager中。从而完成整个通信��程�?br />
事�g分发��程
用户在触发一个时间后产生一个消息，消息先被window manager采集刎ͼ�然后分发�l�client�?br /> window manager通过IWindow分发�l�client�Q�我们知道ViewRoot使用IWindowSession与server通讯�Q��用IWindow接收消息�Q�所以第一步消息到了ViewRoot�q�里来了
也就是window manager->IWindow->ViewRoot
��C��ViewRoot后它把消息�{发给Looper�Q�楼��d��以看ViewRoot.java看它是怎么获取当前�U�程的Looper�?
Looper->ViewRoot$RootHandler().dispatch()�Q�有转发会给ViewRoot�Q�然后就通过decor view形成的树(w��i)状结构依�ơ分发下厅R�?br />
window manager proxy中维护了view, ViewRoot, layout param三元�l��?br /> 每次调用window manager proxy的addView都会新增一个三元组。一般程序中都是调用addView(decor,...)�Q�也��是只对decor view调用addView

*****************\
在Activity在performLaunchActivity�Ӟ��会��用Activity.attach�Q�）建立一个PhoneWindow�ȝ��口。这个主�H�口的徏立�ƈ不是一个重炏V��handleResumeActivity真正要启动一个Activity时候，��主�H�口加入到WindowManager�Q�当然�ƈ不是��主�H�口本��n�Q�而是��主�H�口的DecorView加入到WindowManager中�?br />
• performLaunchActivity@ActivityThread.java
attach()@Activity.javaSession.java
addWindow()@WindowManager

mWindow = PolicyManager.makeNewWindow(this); --实例化一个activity或者dialog或者widget的地�Ҏ(gu��)��会make new window
• handleResumeActivity()@ActivityThread.java
addView()@WindowManagerImpl.java --��d��DecorView到WindowManager�?br /> setView()@ViewRoot.java
add()@IwindowSession.java
| --�q�里通过AIDL调用
add()@WindowManagerService$Service.java

关于PhoneWindow�Q?br /> 而PhoneWindow只是做了一个具体跟手机功能相关的公用事件的处理�Q�所以在Android中PhoneWindow�q�不是一个抽象的�U�正概念�Q�而是一个跟手机�pȝ��相关的一个特别窗口概念，例如按键的默认动作处理，按键音的发出�{�等�?br />
一个View对应一个ViewRoot

问题�Q?strong style="background-color: yellow">WindowMangerService如果通过AIDL��事件派发到客户端的�Q?/strong>

calvin 2010-11-24 18:28 发表评论

[原]Activity启动�q�程分析

calvin — Tue, 23 Nov 2010 06:59:00 GMT
启动activity�Q?br /> **android.process.acore�q�程
1.Acticity.startActivityForResult()
2.Instrumention.execStartActivity();
3.ActivityManagerNative.getDefault()
                .startActivity()
3.1 ActivityManagerNative.getDefault()�q�回的是ActivityManagerProxy的实例，
它只是一个代理类�Q�这个代理类实际上代理的是IBinder b = ServiceManager.getService("activity");
�q�个Service�?br /> 3.2 �q�个Service是什么时候添加进来的呢？
在SystemServer.java的run()中有调用
ActivityManagerService.setSystemProcess();
      ServiceManager.addService("activity", m);
      �q�里�q�会��d��许多�pȝ��关键服务�?br />       �Q�TODO�Q�查看在SystemServer的Log输出�Q?br />
**system_process�q�程
4 ActivityManagerNative
    |--ActivityManagerService

    在ActivityManagerNative的onTransact�Ҏ(gu��)��中最�l�提供了服务�Q?br />     case START_ACTIVITY_TRANSACTION�Q?br />       ActivityManagerService.startActivity�Q�）;
        --startActivityLocked(IApplicationThread caller,
            Intent intent, String resolvedType,
            Uri[] grantedUriPermissions,
            int grantedMode, ActivityInfo aInfo, IBinder resultTo,
            String resultWho, int requestCode,
            int callingPid, int callingUid, boolean onlyIfNeeded,
            boolean componentSpecified)
          --startActivityUncheckedLocked(r, sourceRecord,
                grantedUriPermissions, grantedMode, onlyIfNeeded, true)
          在这个方法里面检查权限，解析intent中的Flag。。�?br />           --startActivityLocked(HistoryRecord r, boolean newTask)
            --resumeTopActivityLocked(HistoryRecord prev)
              --startSpecificActivityLocked(HistoryRecord r,boolean andResume, boolean checkConfig)
                --startProcessLocked(String processName,ApplicationInfo info, boolean knownToBeDead, int intentFlags,String hostingType, ComponentName hostingName)
                  --startProcessLocked(ProcessRecord app,String hostingType, String hostingNameStr)
                    在这里启动一个进�E�用来host�q�个应用
                    int pid = Process.start("android.app.ActivityThread",
                    mSimpleProcessManagement ? app.processName : null, uid, uid,
                    gids, debugFlags, null);

ActivityManagerService.java
--startSpecificActivityLocked(HistoryRecord r,boolean andResume, boolean checkConfig)
--realStartActivityLocked(HistoryRecord r,ProcessRecord app, boolean andResume, boolean checkConfig)
    --app.thread.scheduleLaunchActivity                                   //scheduleLaunchActivity()@IApplicationThread.java
      --scheduleLaunchActivity()@ActivityThread.java                      //�q�里实际是ApplicationThreadNative提供的服�?br />         --handleMessage()@H$ActivityThread.java
          --handleLaunchActivity()@ActivityThread.java
            --Activity performLaunchActivity(ActivityRecord r, Intent customIntent)@ActivityThread.java //�q�时真正的Activity对象被构造出�?br />               --mInstrumentation.newActivity�Q�）                            //通过反射构造出Activity对象
              --activity.attach�Q�）                                         //初始化Activity�Q�生成一个window对象�Q�设�|�各�U�状态等�{?br />               --mInstrumentation.callActivityOnCreate(activity, r.state); //调用Activity的onCreate()�Ҏ(gu��)��

              到这里，我们自己写的activity的onCreate()�Ҏ(gu��)��已经被系�l�调用了�Q�接下来依次回调生命周期�Ҏ(gu��)��Q?br />               --activity.performStart();
                --mInstrumentation.callActivityOnStart(this);
              --mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
              --mInstrumentation.callActivityOnPostCreate(activity, r.state);
              --mActivities.put(r.token, r);                               //��这个activity入栈

            然后��p��调用onResume()�Ҏ(gu��)��了：
            --handleResumeActivity(IBinder token, boolean clearHide, boolean isForward)
              --performResumeActivity(token, clearHide);
                --r.activity.performResume();
                  --performRestart()@Activity.java;
                    --mInstrumentation.callActivityOnRestart(this);
                    --mInstrumentation.callActivityOnStart(this);
                --mInstrumentation.callActivityOnResume(this);
                onResume()已经调用完毕�Q�一个activity的逻辑处理�l�束了，但是�q�时候屏�q�上�q�不会显�C�Z�Q何东西，因�ؓView�q�没有添加进�?br />

              --r.window.getDecorView();                                   //开始把DecorView��d��q�Window
              --wm.addView(decor, l);

            ��x��一个Activity启动�l�束�?br />

calvin 2010-11-23 14:59 发表评论

PDP context相关

calvin — Tue, 23 Nov 2010 06:50:00 GMT

GPRS-PDP上下文的�Ȁ�z�过�E?(摘�?

about PDP context

calvin 2010-11-23 14:50 发表评论

calvin — Tue, 23 Nov 2010 06:12:00 GMT

GsmDataConnectionTracker在实例化�Ӟ��会注册一个观察者，监视apn数据库的变化�?br /> p.getContext().getContentResolver().registerContentObserver(
                Telephony.Carriers.CONTENT_URI, true, apnObserver);

当改变apn后，Settings应用更新apn数据库，ApnChangeObserver的onChange被调用，发送EVENT_APN_CHANGED消息�Q?br /> sendMessage(obtainMessage(EVENT_APN_CHANGED));

接着onApnChanged()@GsmDataConnectionTracker.java被调�?br />       -trySetupData(Phone.REASON_APN_CHANGED)@GsmDataConnectionTracker.java
        --setupData(String reason)@GsmDataConnectionTracker.java

        private boolean setupData(String reason) {
        ApnSetting apn;
        GsmDataConnection pdp;

        apn = getNextApn();
        if (apn == null) return false;

        //获取一个状态�ؓinactive的pdp�q�接对象
        pdp = findFreePdp();
        if (pdp == null) {
            if (DBG) log("setupData: No free GsmDataConnection found!");
            return false;
        }
        mActiveApn = apn;
        mActivePdp = pdp;

        Message msg = obtainMessage();
        msg.what = EVENT_DATA_SETUP_COMPLETE;
        msg.obj = reason;

        //开始激�z�这个pdp
        //在android2.0.1版本�Ӟ��有一个PdpConnection.java来进行连接，2.2时这个类被删掉了�Q�connect的功能合�q�到GsmDataConnection里面
        pdp.connect(msg, apn);

        //讄��q�个pdp�q�接状态�ؓINITING
        setState(State.INITING);
        if (DBG) log("setupData for reason: "+reason);

        //通知上层应用数据�q�接状态改�?br />         phone.notifyDataConnection(reason);
        return true;
    }

    其中�Q�在�q�一层，数据�q�接�׃��个状态：
        IDLE,
        INITING,
        CONNECTING,
        SCANNING,
        CONNECTED,
        DISCONNECTING,
        FAILED

        对上层应用来��_��q�七个状态划分�ؓ四种状态（getDataConnectionState()@GSMPhone.java�Q�：
        CONNECTED, CONNECTING, DISCONNECTED, SUSPENDED;
        分别对应TelephonyManager的四�U�连接状态�?br />
        开始激�z�PDP�q�接�Ӟ��讄��状态�ؓState.INITING�Q�调用phone.notifyDataConnection(reason)发出通知�Q�后�l�调用过�E��ؓ�Q?br />         notifyDataConnection(String reason)@PhoneBase.java
          --notifyDataConnection(Phone sender, String reason)@DefaultPhoneNotifier.java
            .
            .   �q�里需要经�q�IPC调用
            .
            notifyDataConnection()@TelephonyRegistry.java
              --onDataConnectionStateChanged()

当连接成功后�Q�onDataSetupComplete�Q�）@GsmDataConnectionTracker.java被调�?br /> 通过phone.notifyDataConnection(reason);回调应用层的onDataConnectionStateChanged()�Ҏ(gu��)��?br />
ps:可以通过adb logcat -b radio查看�Ȁ�z�L��据连接时�Q�radio层的log输出�?br />

calvin 2010-11-23 14:12 发表评论

利用onUserLeaveHint发送后台运行通知

calvin — Mon, 22 Nov 2010 05:26:00 GMT
背景�Q?br /> 用户按下Home键将�E�序�|�于后台�q�行或者应用启动其他activity�Q�比如系�l�浏览器�Q�短信等�Q�需要向�pȝ��发送通知�Q�用户做完别的操作后�Q�点击通知栏，回到应用�?br />
问题一
在什么时机发送通知�Q?br /> 用户按下Home的事件在应用层时捕捉不到的，因此只能从activity生命周期�Ҏ(gu��)��着手�?br />
�Ҏ(gu��)��一�Q?br /> �pȝ��所有activity�l�承一个BaseActivity�Q�在BaseActivity中维护一个当前可见的activity数组�Q?br /> protected static ArrayList sVisibleActivities = new ArrayList();

在onResume中，��当前activity保存�Q�同时清除所有通知�Q?br /> protected void onResume()
{
if (!sVisibleActivities.contains(this))
{
sVisibleActivities.add(this);
}

// 清除�pȝ��消息
mNotificationManager.cancel(R.id.notify);
}

在onStop中，清除保存的当前activity�Q?br /> protected void onStop()
{
if (sVisibleActivities.contains(this))
{
sVisibleActivities.remove(this);
}

// 如果当前没有可见的activity�Q�则发送系�l�通知
if (sVisibleActivities.isEmpty())
{
sendBackgroundNotify();
}

super.onStop();
}

�q�种方式在大多数情况下工作良好，可以辑ֈ�需求，但是问题�Ӟ��当前台的activity被至于后台时�Q�onStop()�Ҏ(gu��)��不一定会被调用，因此通知有可能不会被发出�Q?br />
�Ҏ(gu��)��二：
几经周折�Q�发现activity有一个生命周期方法可以达到目的：

protected void onUserLeaveHint ()

Since: API Level 3
Called as part of the activity lifecycle when an activity is about to go into the background as the result of user choice.
For example, when the user presses the Home key, onUserLeaveHint() will be called, but when an incoming phone call causes the in-call Activity to be automatically brought to the foreground,
onUserLeaveHint() will not be called on the activity being interrupted. In cases when it is invoked, this method is called right before the activity's onPause() callback.
This callback and onUserInteraction() are intended to help activities manage status bar notifications intelligently; specifically, for helping activities determine the proper time to cancel a notfication.

从文档来看，�q�个�Ҏ(gu��)��g��是��Z��按下Home键时�q�样的场景设计的�?br /> �q�样�Q�在onUserLeaveHint里发出系�l�通知卛_��?br /> 但是问题又来了，如果启动应用�Q�从一个activity依次调用startActivity�Q�finish关闭自己�Q�启动一个新的activity�Ӟ��onUserLeaveHint也会被调�?...

再次��阅文档�Q�发现Intent中的一个Flag�Q?br />

public static final int FLAG_ACTIVITY_NO_USER_ACTION

Since: API Level 3
If set, this flag will prevent the normal onUserLeaveHint() callback from occurring on the current frontmost activity before it is paused as the newly-started activity is brought to the front.

Typically, an activity can rely on that callback to indicate that an explicit user action has caused their activity to be moved out of the foreground.
The callback marks an appropriate point in the activity's lifecycle for it to dismiss any notifications that it intends to display "until the user has seen them," such as a blinking LED.
If an activity is ever started via any non-user-driven events such as phone-call receipt or an alarm handler, this flag should be passed to Context.startActivity, ensuring that the pausing activity does not think the user has acknowledged its notification.

�q�正是我惌��的，�q�样�Q�在启动activity�Ӟ��往intent中加上这个flag�Q�onUserLeaveHint��׃��会再被调用了�Q�hoory...

calvin 2010-11-22 13:26 发表评论

calvin — Fri, 19 Nov 2010 07:25:00 GMT
�?.5中，有个PppLink.java文�g�Q�封装了启动pppd�q�程的接口，但是�?.6版本的时候这个文件被删除了，与之相关的代码也全删了，不知其解�Q�网上搜得解�{�如下：

因�ؓ高通的�Ҏ(gu��)��Q�采用共享内存的�Ҏ(gu��)��Q�不需要pppd拨号了。google�q�帮人就认�ؓ不需要pppd了，也就把PppLink.java删除了。所�?.6之后�Q�还需要pppd拨号的，��需要把1.5拨号�q�块�U�L��回来.

参见�Q?br /> http://topic.csdn.net/u/20091022/16/6e5b6a99-3af6-421a-b6f1-e0752e239077.html

calvin 2010-11-19 15:25 发表评论

[转]Task和Activity相关

calvin — Fri, 19 Nov 2010 06:32:00 GMT
Task和Activity相关

�q�段旉��在做一个项目，发现对Task和Activity掌握的还是不牢固。把相关知识整理在这里，方便查阅�Q�有几个Flag没看明白啥意思，也没��试出来效果如何。。�?br />
android:allowTaskReparenting
用来标记Activity能否从启动的Task�U�d��到有着affinity的Task�Q�当�q�个Task�q�入到前台时�Q�—�?#8220;true”�Q�表�C��U�d��Q?#8220;false”�Q�表�C�它必须呆在启动时呆在的那个Task里�?br /> 如果�q�个�Ҏ(gu��)��没有被讑֮��Q�设定到元素上的allowTaskReparenting�Ҏ(gu��)��的��g��应用到Activity上。默认��gؓ“false”�?br /> 一般来��_��当Activity启动后，它就与启动它的Task兌��Q��ƈ且在那里耗尽它的整个生命周期。当当前的Task不再昄��Ӟ��你可以��用这个特性来强制Activity�U�d��到有着affinity的Task中。典型用法是�Q�把一个应用程序的Activity�U�d��另一个应用程序的主Task中�?br /> 例如�Q�如果e�Q�mail中包含一个web��늚�链接�Q�点��d��?y��u)�׃��启动一个Activity来显�C��个页面。这个Activity是由Browser应用�E�序定义的，但是�Q�现在它作�ؓe�Q�mail Task的一部分。如果它重新宿主到Browser Task里，当Browser下一�ơ进入到前台�Ӟ��它就能被看见�Q��ƈ且，当e�Q�mail Task再次�q�入前台�Ӟ��q��不到它了�?br /> Actvity的affinity是由taskAffinity�Ҏ(gu��)��定义的。Task的affinity是通过��d��根Activity的affinity军_��。因此，�Ҏ(gu��)��定义�Q�根Activity��L��位于相同affinity的Task里。由于启动模式�ؓ“singleTask”�?#8220;singleInstance”的Activity只能位于Task的底部，因此�Q�重新宿��d��能限�?#8220;standard”�?#8220;singleTop”模式�?br />
android:alwaysRetainTaskState
用来标记Activity所在的Task的状态是否��L��q��l�来保持—�?#8220;true”�Q�表�C��L��Q?#8220;false”�Q�表�C�在某种情�Ş下允许系�l�恢复Task到它的初始化状态。默认值是“false”。这个特性只针对Task的根Activity有意义；对其它Activity来说�Q�忽略之�?br /> 一般来��_��特定的情形如当用户从�ȝ��面重新选择�q�个Task�Ӟ��pȝ��会对�q�个Task�q�行清理�Q�从stack中删除位于根Activity之上的所有Activivity�Q�。典型的情况�Q�当用户有一�D�|��间没有访问这个Task时也会这么做�Q�例�?0分钟�?br /> 然而，当这个特性设�?#8220;true”�Ӟ��用户��L��能回到这个Task的最新状态，无论他们是如何启动的。这非常有用�Q�例如，像Browser应用�E�序�Q�这里有很多的状态（例如多个打开的Tab�Q�，用户不想丢失�q�些状态�?br />
android:clearTaskOnLaunch
用来标记是否从Task中清除所有的Activity�Q�除了根Activity外（每当从主画面重新启动�Ӟ��—�?#8220;true”�Q�表�C��L��清除臛_��的根Activity�Q?#8220;false”表示不。默认值是“false”。这个特性只对启动一个新的Task的Activity�Q�根Activity�Q�有意义�Q�对Task中其它的Activity忽略�?br /> 当这个��gؓ“true”�Q�每�ơ用户重新启动这个Task�Ӟ��都会�q�入到它的根Activity中，不管�q�个Task最后在做些什么，也不��用��h��使用BACK�q�是HOME��d��的。当�q�个��gؓ“false”�Ӟ��可能会在一些情形下�Q�参考alwaysRetainTaskState�Ҏ(gu��)��）清除Task的Activity�Q�但不��L��?br /> 假设�Q�某��Z��ȝ��面启动了Activity P�Q��ƈ从那里迁�U�至Activity Q。接下来用户按下HOME�Q�然后返回Activity P。一般，用户可能见到的是Activity Q�Q�因为它是P的Task中最后工作的内容。然而，如果P讑֮��q�个�Ҏ(gu��)��ؓ“true”�Q�当用户按下HOME�q��ɘq�个Task再次�q�入前台�Ӟ��其上的所有的Activity(在这里是Q)都将被清除。因此，当返回到�q�个Task�Ӟ��用户只能看到P�?br /> 如果�q�个�Ҏ(gu��)��和allowTaskReparenting都设定�ؓ“true”�Q�那些能重新宿主的Activity会移动到�׃�naffinity的Task中；剩下的Activity都将被抛弃，如上所�q��?br />
android:finishOnTaskLaunch
用来标记当用户再�ơ启动它的Task�Q�在�ȝ��面选择�q�个Task�Q�时已经存在的Activity实例是否要关闭（�l�束�Q�—�?#8220;true”�Q�表�C�应该关闭，“false”表示不关闭。默认值是“false”�?br /> 如果�q�个�Ҏ(gu��)��和allowTaskReparenting都设定�ؓ“true”�Q�这个特性胜出。Activity的affinity忽略。这个Activity不会重新宿主�Q�但是会销毁�?br />
android:launchMode
用于指示Activity如何启动。这里有四种模式�Q�与Intent对象中的Activity Flags�Q�FLAG_ACTIVITY_*变量�Q�共同作用，来决定Activity如何启动来处理Intent。它们是�Q?br />
"standard"
"singleTop"
"singleTask"
"singleInstance"

默认模式�?#8220;standard”�?br />
�q�些模式可以分成两大�l�别�Q?#8220;standard”�?#8220;singleTop”一�l�，“singleTask”�?#8220;singleInstance”一�l�。具�?#8220;standard”�?#8220;singleTop”启动模式的Activity可以实例化很多次。这些实例可以属于�Q何Task�q�且可以位于Activity stack的�Q何位�|�。典型的情况是，它们会进入调用startActivity()的Task�Q�除非Intent对象包含FLAG_ACTIVITY_NEW_TASK标志�Q�在�q�种情况下会选择一个不同的Task——参考taskAffinity�Ҏ(gu��)��）�?br /> 相反的，“singleTask”�?#8220;singleInstance”只能启动一个Task。它们��L��位于Activity stack的底部。甚臻I��讑֤�一�ơ只能拥有一个Activity的实例——只有一个这��L(f��ng)��Task�?br /> “standard”�?#8220;singleTop”模式只在一�U�情况下有差别：每次有一个新的启�?#8220;standard”Activity的Intent�Q�就会创��Z��个新的实例来响应�q�个Intent。每个实例处理一个Intent。相似的�Q�一�?#8220;singleTop”的Activity实例也有可能被创建来处理新的Intent。然而，如果目标Task已经有一个存在的实例�q�且位于stack的顶部，那么�Q�这个实例就会接收到�q�个新的Intent�Q�调用onNewIntent()�Q�；不会创徏新的实例。在其他情况下——例如，如果存在�?#8220;singleTop”的Activity实例在目标Task中，但不是在stack的顶部，或者它在一个stack的顶部，但不是在目标Task中——新的实例都会被创徏�q�压入stack中�?br /> “singleTask”�?#8220;singleInstance”模式也只在一�U�情况下有差别：“singleTask”Activity允许其它Activity成�ؓ它的Task的部分。它位于Activity stack的底部，其它Activity�Q�必��L��“standard”�?#8220;singleTop”Activity�Q�可以启动加入到相同的Task中�?#8220;singleInstance”Activity�Q�换句话��_��不允许其它Activity成�ؓ它的Task的部分。它是Task中的唯一Activity。如果它启动其它的Activity�Q�这个Activity会被攄��到另一个task中——好像Intent中包含了FLAG_ACTIVITY_NEW_TASK标志�?br />
android:noHistory
用于标记当用户从Activity上离开�q�且它在屏幕上不再可见时Activity是否从Activity stack中清除�ƈ�l�束�Q�调用finish()�Ҏ(gu��)��Q�—�?#8220;true”�Q�表�C�它应该关闭�Q?#8220;false”�Q�表�C�Z��需要。默认值是“false”�?br /> “true”值意味着Activity不会留下历史痕迹。因为它不会在Activity stack的Task中保留，因此�Q�用户不能返回它�?br />
android:taskAffinity
Activity为Task拥有的一个affinity。拥有相同的affinity的Activity理论上属于相同的Task�Q�在用户的角度是相同�?#8220;应用�E�序”�Q�。Task的affinity是由它的根Activity军_��的�?
affinity军_��两�g事情——Activity重新宿主的Task�Q�参考allowTaskReparenting�Ҏ(gu��)��）和��用FLAG_ACTIVITY_NEW_TASK标志启动的Activity宿主的Task�?br /> 默认情况�Q�一个应用程序中的所有Activity都拥有相同的affinity。捏可以讑֮��q�个�Ҏ(gu��)��来重组它们�Q�甚臛_��以把不同应用�E�序中定义的Activity攄��到相同的Task中。�ؓ了明��Activity不宿�ȝ��定的Task�Q�设定该�Ҏ(gu��)��ؓ�I�的字符丌Ӏ?br /> 如果�q�个�Ҏ(gu��)��没有设�|�，Activity��从应用�E�序的设定那里��承下来（参�?application>元素的taskAffinity�Ҏ(gu��)��）。应用程序默认的affinity的名字是元素中设定的package名�?br />
FLAG_ACTIVITY_BROUGHT_TO_FRONT
�q�个标志一般不是由�E�序代码讄��的，如在launchMode中设�|�singleTask模式时系�l�帮你设定�?br />
FLAG_ACTIVITY_CLEAR_TOP
如果讄��Q��ƈ且这个Activity已经在当前的Task中运行，因此�Q�不再是重新启动一个这个Activity的实例，而是在这个Activity上方的所有Activity都将关闭�Q�然后这个Intent会作��Z��个新的Intent投递到老的Activity�Q�现在位于顶端）中�?br /> 例如�Q�假设一个Task中包含这些Activity�Q�A�Q�B�Q�C�Q�D。如果D调用了startActivity()�Q��ƈ且包含一个指向Activity B的Intent�Q�那么，C和D都将�l�束�Q�然后B接收到这个Intent�Q�因此，目前stack的状冉|��Q�A�Q�B�?br /> 上例中正在运行的Activity B既可以在onNewIntent()中接收到�q�个新的Intent�Q�也可以把自己关闭然后重新启动来接收�q�个Intent。如果它的启动模式声明�ؓ“multiple”(默认�?�Q��ƈ且你没有在这个Intent中设�|�FLAG_ACTIVITY_SINGLE_TOP标志�Q�那么它?y��u)��关闭然后重新创建；对于其它的启动模式，或者在�q�个Intent中设�|�FLAG_ACTIVITY_SINGLE_TOP标志�Q�都��把�q�个Intent投递到当前�q�个实例的onNewIntent()中�?br /> �q�个启动模式�q�可以与FLAG_ACTIVITY_NEW_TASK�l�合��h��使用�Q�用于启动一个Task中的根Activity�Q�它会把那个Task中�Q何运行的实例带入前台�Q�然后清除它直到根Activity。这非常有用�Q�例如，当从Notification Manager处启动一个Activity�?br />
FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET
如果讄��Q�这��在Task的Activity stack中设�|�一个还原点�Q�当Task恢复�Ӟ��需要清理Activity。也��是��_��下一�ơTask带着FLAG_ACTIVITY_RESET_TASK_IF_NEEDED标记�q�入前台�Ӟ��典型的操作是用户在主画面重启它）�Q�这个Activity和它之上的都��关闭，以至于用户不能再�q�回到它们，但是可以回到之前的Activity�?br /> �q�在你的�E�序有分割点的时候很有用。例如，一个e-mail应用�E�序可能有一个操作是查看一个附�Ӟ��需要启动图片浏览Activity来显�C�。这个Activity应该作�ؓe-mail应用�E�序Task的一部分�Q�因��是用户在�q�个Task中触发的操作。然而，当用��L(f��ng)��开�q�个Task�Q�然后从�ȝ��面选择e-mail app�Q�我们可能希望回到查看的会话中，但不是查看图片附�Ӟ��因�ؓ�q�让人困惑。通过在启动图片浏览时讑֮��q�个标志�Q�浏览及其它启动的Activity在下�ơ用戯��回到mail�E�序旉��全部清除�?br />
FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS
如果讄��Q�新的Activity不会在最�q�启动的Activity的列表中保存�?br />
FLAG_ACTIVITY_FORWARD_RESULT
如果讄��Q��ƈ且这个Intent用于从一个存在的Activity启动一个新的Activity�Q�那么，�q�个作�ؓ�{�复目标的Activity��会传到�q�个新的Activity中。这�U�方式下�Q�新的Activity可以调用setResult(int)�Q��ƈ且这个结果值将发送给那个作�ؓ�{�复目标的Activity�?br />
FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY
�q�个标志一般不由应用程序代码设�|�，如果�q�个Activity是从历史记录里启动的�Q�常按HOME键）�Q�那么，�pȝ��会帮你设定�?br />
FLAG_ACTIVITY_MULTIPLE_TASK
不要使用�q�个标志�Q�除非你自己实现了应用程序启动器。与FLAG_ACTIVITY_NEW_TASK�l�合��h��使用�Q�可以禁用把已存的Task送入前台的行为。当讄��Ӟ��新的Task��L��会启动来处理Intent�Q�而不��这是是否已�l�有一个Task可以处理相同的事情�?br /> �׃��默认的系�l�不包含囑�ŞTask��理功能�Q�因此，你不应该使用�q�个标志�Q�除非你提供�l�用户一�U�方式可以返回到已经启动的Task�?br /> 如果FLAG_ACTIVITY_NEW_TASK标志没有讄��Q�这个标志被忽略�?br />
FLAG_ACTIVITY_NEW_TASK
如果讄��Q�这个Activity会成为历史stack中一个新Task的开始。一个Task�Q�从启动它的Activity��C��一个Task中的Activity�Q�定义了用户可以�q�移的Activity原子�l�。Task可以�U�d��到前台和后台�Q�在某个特定Task中的所有Activity��L��保持相同的次序�?br /> �q�个标志一般用于呈�?#8220;启动”�c�d��的行为：它们提供用户一�p�d��可以单独完成的事情，与启动它们的Activity完全无关�?br /> 使用�q�个标志�Q�如果正在启动的Activity的Task已经在运行的话，那么�Q�新的Activity��不会启动；代替的，当前Task会简单的�U�d��前台。参考FLAG_ACTIVITY_MULTIPLE_TASK标志�Q�可以禁用这一行�ؓ�?br /> �q�个标志不能用于调用方对已经启动的Activity��h��l�果�?br />
FLAG_ACTIVITY_NO_ANIMATION
如果在Intent中设�|�，�q�传递给Context.startActivity()的话�Q�这个标志将��L��pȝ��q�入下一个Activity时应用Acitivity�q�移动画。这�q�不意味着动画��永不运行——如果另一个Activity在启动显�C�Z��前，没有指定�q�个标志�Q�那么，动画��被应用。这个标志可以很好的用于执行一�q�串的操作，而动画被看作是更高一�U�的事�g的驱动�?br />
FLAG_ACTIVITY_NO_HISTORY
如果讄��Q�新的Activity��不再历史stack中保留。用户一��d��它，�q�个Activity��关闭了。这也可以通过讄��noHistory�Ҏ(gu��)��?br />
FLAG_ACTIVITY_NO_USER_ACTION
如果讄��Q�作为新启动的Activity�q�入前台�Ӟ��q�个标志��在Activity暂停之前��L��从最前方的Activity回调的onUserLeaveHint()�?br /> 典型的，一个Activity可以依赖�q�个回调指明昑ּ�的用户动作引��L(f��ng)��Activity�U�d��后台。这个回调在Activity的生命周期中标记一个合适的点，�q�关闭一些Notification�?br /> 如果一个Activity通过非用户驱动的事�g�Q�如来电(sh��)或闹钟，启动的，�q�个标志也应该传递给Context.startActivity�Q�保证暂停的Activity不认为用户已�l�知晓其Notification�?br />
FLAG_ACTIVITY_PREVIOUS_IS_TOP
If set and this intent is being used to launch a new activity from an existing one, the current activity will not be counted as the top activity for deciding whether the new intent should be delivered to the top instead of starting a new one. The previous activity will be used as the top, with the assumption being that the current activity will finish itself immediately.

FLAG_ACTIVITY_REORDER_TO_FRONT
如果在Intent中设�|�，�q�传递给Context.startActivity()�Q�这个标志将引发已经�q�行的Activity�U�d��到历史stack的顶端�?br /> 例如�Q�假设一个Task由四个Activity�l�成�Q�A,B,C,D。如果D调用startActivity()来启动Activity B�Q�那么，B会移动到历史stack的顶端，现在的次序变成A,C,D,B。如果FLAG_ACTIVITY_CLEAR_TOP标志也设�|�的话，那么�q�个标志��被忽略�?br />
FLAG_ACTIVITY_RESET_TASK_IF_NEEDED

If set, and this activity is either being started in a new task or bringing to the top an existing task, then it will be launched as the front door of the task. This will result in the application of any affinities needed to have that task in the proper state (either moving activities to or from it), or simply resetting that task to its initial state if needed.

FLAG_ACTIVITY_SINGLE_TOP
如果讄��Q�当�q�个Activity位于历史stack的顶端运行时�Q�不再启动一个新的�?

Activity和Task

之前提到的，一个Activity可以启动另一个，即便是定义在不同应用�E�序中的Activity。例如，假设你想让用��h��C�Z��些地方的街景。而这里已�l�有一个Activity可以做到�q�一点，因此�Q�你的Activity所需要做的只是在Intent对象中添加必要的信息�Q��ƈ传递给startActivity()。地图浏览将会显�C�Z��的地图。当用户按下BACK键，你的Activity会再�ơ出现在屏幕上�?br />
对于用户来说�Q�看��h��好像是地图浏览与你的Activity一��P��属于相同的应用程序，即便是它定义在其它的应用�E�序里，�q�运行在那个应用�E�序的进�E�里。Android通过��这两个Activity保存在同一个Task里来体现�q�一用户体验。简单来��_��一个Task��是用户体验上的一�?#8220;应用”。它?y��u)��相关的Activity�l�合在一��P��以stack的方式管理。stack中根Activity启动Task——典型的�Q�它?y��u)��是用户在应用程序启动栏中选择的Activity。位于stack��端的Activity是当前正在运行的——能够聚焦用��L(f��ng)��动作。当一个Activity启动另一个，新的Activity�q�入stack�Q�它成�ؓ正在�q�行的Activity。之前的Activity仍保留在stack中。当用户按下BACK键，当前的Activity从stack中退出，之前的那个成为正在运行的Activity�?br />
stack包含对象�Q�因此，如果一个Task中有多个同一个Activity的实例时——多个地图浏览，例如——stack为每个实例拥有一个独立的入口。位于stack中的Activity不会重新调整�Q�只是进入和退出�?br />
一个Task��是一�l�Activity�Q�不是一个类或者在manifest中定义的一个元素。因此，没有办法为Task讄��独立于它的Activity的属性倹{��Task的��g��为整体在根Activity中设�|�。例如，下一个章节会讨论Task�?#8220;affinity”�Q�那个值就是从Task中的根Activity中读取的�?br />
Task中的所有Activity作�ؓ一个单元一��L(f��ng)��动。整个Task�Q�整个Activity stack�Q�可以进入前台或者退到后台。例如，假设当前Task中的stack中有4个Activity—�?个位于当前Activity下方。用��h��下HOME键，�q�入到应用程序启动栏�Q�然后选择一个新的应用程序（实际上，一个新的Task�Q�。当前Task退到后収ͼ��q�且新Task中的根Activity会显�C�出来。然后，�l�过一�D�|��间后�Q�用户回到Home画面�Q�然后再�ơ选择前一个应用程序（前一个Task�Q�。那个拥�?个Activity的Task会进入前台。当用户按下BACK键，屏幕不会昄��用户刚刚��d��的Activity�Q�前一个Task的根Activity�Q�。而是�Q�这个stack中的��端Activity�U�除�Q�相同Task中的前一个Activity会显�C�出来�?br />
刚才描述的行为是Activity和Task的默认行为。但有方法来完全改变它。Task之间的关联，和一个Task中的一个Activity行�ؓ�Q�受启动Activity的Intent对象中设�|�的Flag和manifest文�g中Activity�?activity>元素的特性��g��互控制。调用者和响应者都有权军_��如何发生�?br />
核心的Intent Flag有：
FLAG_ACTIVITY_NEW_TASK
FLAG_ACTIVITY_CLEAR_TOP
FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
FLAG_ACTIVITY_SINGLE_TOP

核心�?activity>�Ҏ(gu��)��有�Q?br /> taskAffinity
launchMode
allowTaskReparenting
clearTaskOnLaunch
alwaysRetainTaskState
finishOnTaskLaunch

接下来的章节��描�q�C��些Flag和特性的用法�Q�如何相互媄响，以及在��用时的徏议�?br />
Affinity和新Task
默认情况下，一个应用程序中的所有Activity都有affinity——也��是��_��属于同一个Task中所有Activity有一个设定。然而，每个Activity都可以在元素的taskAffinity�Ҏ(gu��)��上讄��单独的倹{��定义在不同应用�E�序中的Activity可以�׃�n同一个affinity�Q�或者定义在同一个应用程序中的Activity讄��不同的affinity。Affinity在两�U�环境下工作�Q�Intent对象包含FLAG_ACTIVITY_NEW_TASK标志�Q�和Activity的allowTaskReparenting�Ҏ(gu��)��设�|��ؓ“true”�?br /> FLAG_ACTIVITY_NEW_TASK:
之前描述的，一个Activity一般通过调用startActivity()启动�q�加入到Task中。它同调用者一��P��q�入同一个Task。然而，如果传递给startActivity()的Intent对象中包含FLAG_ACTIVITY_NEW_TASK�Ӟ��pȝ��会搜索一个新的Task来容�U�x��的Activity。通常�Q�如标志的名字所�C�，是一个新的Task。然而，�q�不是必��L��。如果已�l�存在一个Task与新Activity的affinity相同�Q�这个Activity��׃��加入到那个Task中。如果不是，启动一个新的Task�?br /> allowTaskReparenting�Q?br /> 如果一个Activity的allowTaskReparenting�Ҏ(gu��)��设�|��ؓ“true”�Q�它?y��u)��p��从启动的Task中移到有着相同affinity的Task�Q�这个Task�q�入到前台的时候）。例如，在一个旅游的�E�序中定义了一个可以报告选择城市的天气情�늚�Activity。它和同一个应用程序的其它Activity一��P��有着相同的Affinity�Q�默认的Affinity�Q�，�q�且它允�?d��ng)R��新宿丅R��你的Activity中的一个启动了天气预报�Q�因此，它初始化到和你Activity相同的Task中。然而，当旅游应用程序下一�ơ进入到前台�Ӟ��天气预报那个Activity��会重新�~�排�q�在那个Task中显�C��?br />
如果从用��L(f��ng)��角度出发�Q�一�?apk文�g包含多个“应用”的话�Q�你可能希望为关联的Activity讄��不同的affinity�?br />
Launch Mode

�q�里4�U�不同的启动模式可以讄��?activity>元素的launchMode�Ҏ(gu��)��上�Q?br /> standard�Q�默认模式）
singleTop
singleTask
singleInstance

�q�些模式有以下四点区别：
l 哪个Task��容�U�_��应Intent的Activity。对�?#8220;standard”�?#8220;singleTop”来说�Q�是产生Intent的那个Task�Q��ƈ调用startActivity()�Q�——除非Intent对象包含FLAG_ACTIVITY_NEW_TASK。在那种情况下，不同的Task��被选择�Q�如“Affinity和新Task”中描�q�的那样。对比而言�Q?#8220;singleTask”�?#8220;singleInstance”指示Activity��L��一个Task的根。它们定义一个Task�Q�它们不会加入到另一个Task中�?br /> l 是否有多个Activity的实例�?#8220;standard”�?#8220;singleTop”可以实例化多�ơ。它们可以属于多个Task�Q�一个特定的Task可以有相同Activity的多个实例。对比而言�Q?#8220;singleTask”�?#8220;singleInstance”只能有一个实例。因��些Activity只能位于Task的底部，�q�一限制意味着在设备的某个旉��Q�不会出现这样Task的多个实例�?br /> l 是否可以在同一个Task中拥有其它的Activity�?#8220;singleInstance”Activity保持单��n�Q�在它的Task中它是仅有的Activity。如果它启动另一个Activity�Q�那个Activity��会攑օ��C��同的Task中，而不��它的启动模式——好像FLAG_ACTIVITY_NEW_TASK在Intent中一栗��对于其它方面，�Q?#8220;singleInstance”�{�同�?#8220;singleTask”。其它三个模式允许多个Activity加入到这个Task中�?#8220;singleTask”Activity��L��位于Task的底部，但它可以启动其它的Activity�q�放入到它的Task中�?#8220;standard”�?#8220;singleTop”的Activity可以出现在stack的�Q何地斏V�?br /> l 是否一个新的实例启动来处理新的Intent。对于默认的“standard”来说�Q�都是创��Z��个新的实例来响应新的Intent。每个实例处理一个Intent。对�?#8220;singleTop”来说�Q�如果它位于目标Task的顶端，那么�Q�已�l�存在的实例��可以重复��用来处理�q�个新的Intent。如果它不在��端�Q�那么它?y��u)�׃��能重复��用。替代的�Q�新的实例将创徏来响应新的Intent�Q��ƈ�q�入到stack中�?br /> 例如�Q�假设一个Task的Activity stack中包含根Activity A和其它Activity B�Q�C�Q�D�Q��ƈ且D位于��端�Q�因此，stack是A-B-C-D。有一个Intent来了�Q�它要启动D�c�d��的Activity。如果D有默认的“standard”启动模式�Q�那么，一个新的实例将被启动�ƈ且stack变成A-B-C-D-D。然而，如果D的启动模�?#8220;singleTop”�Q�已�l�存在的实例��去处理新来的Intent�Q�因为它正好处在stack的顶端）�Q��ƈ且stack依旧是A-B-C-D�?br /> 换句话说�Q�如果来临的Intent是冲着B�c�d��的，那么�Q�B�c�d��的实例将被创建启动而不��B的模式是“standard”�?#8220;singleTop”�Q�因为B不处在stack的顶端）�Q�因此，stack��会是A-B-C-D-B�?br /> 之前提到的，讑֤�上不会出现超�q�一个实例的“singleTask”�?#8220;singleInstance”Activity�Q�因此，那个实例都将��d��理所有新来的Intent�?#8220;singleInstance”Activity��L��位于stack的顶端（因�ؓ它是task中唯一的Activity�Q�，因此�Q�它��L��处于能处理Intent的位�|�。然而，“singleTask”Activity可能有或没有其它Activity处于它的上方。如果有�Q�它?y��u)�׃��处于能处理Intent的位�|�，那么�Q�这个Intent��被丢弃。（即��Intent被丢弃了�Q�它的到来会引发那个Task�q�入到前収ͼ�在那里，它会�l�箋保留。）

当一个存在的Activity��h��d��理一个新的Intent�Ӟ��Intent对象��传到该Activity的onNewIntent()的方法中。（原来启动Activity的Intent对象可以通过调用getIntent()得到。）

注意�Q�当一个新的实例创建来处理新的Intent�Ӟ��用户可以按下BACK键返回到之前的状态（前一个Activity�Q�。但一个存在的实例来处理新的Intent�Ӟ��用户不能按下BACK键返回到新Intent到来之前的状态�?br />
清除stack
如果用户��d��Task很长一�D�|��_��pȝ��会清除Task中的所有Activity�Q�除根Activity外。当用户再次�q�回到这个Task�Ӟ��和用��L(f��ng)��开时一��P��仅仅只是初始化Activity呈现。这样做的意图是�Q�经�q�一些时间后�Q�用户可能已�l�忘��C��前正在做的事情，�q�且打算回到Task开始些新的时期�?br />
�q�是默认情况。这里有一些Activity�Ҏ(gu��)��可以用于控制这一行�ؓ�q�且修改它：
alwaysRetainTaskState�Q?br /> 如果Task的根Activity的这个特性设�|��ؓ“true”�Ӟ��上面描述的默认行��Z��会发生。Task保留所有的Activity�Q�即便是�l�过很长一�D�|��间�?br /> clearTaskOnLaunch�Q?br /> 如果Task的根Activity的这个特性设�|��ؓ“true”�Ӟ��当用��L(f��ng)��开Task�q�返回时�Q�stack会清除直到根Activity。换句话��_��它是alwaysRetainTaskState的另一个极端。用��h��L��回到Task的初始化状态，即便是一个短暂的��d��?br /> finishOnTaskLaunch�Q?br /> �q�个�Ҏ(gu��)��和clearTaskOnLaunch�怼��Q�但它针对单个Activity�Q�不是整个Task。它能��M��Activity消失�Q�包括根Activity。当它设�|��ؓ“true”�Ӟ��q�个Activity仅在当前会话期间保持为Task的部分。如果用��L(f��ng)��开�q�再�ơ返回到�q�个Task�Q�它?y��u)�׃��再显�C�Z��?br />
�q�里�q�有其它的方式可以强制Activity从stack中移除。如果Intent对象中包含FLAG_ACTIVITY_CLEAR_TOP标志�Q��ƈ且目标Task中已�l�有一个这个类型Activity的实例，而且�q�个实例应该处理�q�个Intent�Q�那么，位于其上的Activity都将�U�除�Q�这��P��q�个Activity��p��在stack的顶端�ƈ响应�q�个Intent。如果这个Activity的启动模式设定�ؓ“standard”�Q�它也会从stack中清除，然后新的实例启动来响应这个Intent。这是因为当启动模式讑֮��?#8220;standard“�Ӟ��L��会创��Z��个新的实例来响应新的Intent�?br />
FLAG_ACTIVITY_CLEAR_TOP�l�常与FLAG_ACTIVITY_NEW_TASK�l�合��h��使用。当一起��用时�Q�这些标志可以定位其它Task中已�l�存在的Activity�Q��ƈ且把它置于可以响应Intent的位�|��?br />
启动Task
如果一个Activity的Intent Filter的action�?#8220;android.intent.action.MAIN”、category�?#8220;android.intent.category.LAUNCHER”�Ӟ��它就可以作�ؓ一个Task的入口点。有�q�种�c�d��的Filter会在��D��q�个Activity在应用程序启动栏昄��一个图标和标签�Q�给用户提供一个方式可以启动这个Task和在��M��时候可以再�ơ回到这个Task�?br />
�W�二个能力很重要�Q�用户一定可以离开一个Task�Q�然后可以再�ơ回到它。基于这个原因，两个启动模式�Q?#8220;singleTask”�?#8220;singleInstance”应该只在有MAIN和LAUNCHER的Activity上��用。例如，假设�q�个Filter没有的话�Q�一个Intent启动了一�?#8220;singleTask”Activity�Q�初始化一个新的Task�Q�然后用戯��费了一些时间在它上面。然后，用户按下HOME键。现在，�q�个Task处于后台�q�且被HOME画面遮盖。由于它不能在应用程序启动栏昄��Q�用户就没有办法可以�q�回它�?br />
在面对FLAG_ACTIVITY_NEW_TASK�Ӟ��也有�怼�的困难。如果这个标志导致一个Activity启动了一个新的Task�Q��ƈ且用��h��下HOME键离开它，�q�里必须有方法可以再�ơ回到它。一些机能（如Notification Manager�Q��L��在外部的Task中启动Activity�Q�而不是作��q��一部分�Q�因此，它��L��把FLAG_ACTIVITY_NEW_TASK标志攑օ�Intent�Q�然后传递给startActivity()。如果你的Activity可能会被外部的机能（可能使用�q�个标志�Q�调用，注意用户可以额外的方式可以返回到启动的Task�?br />
如果你不想用户回到某个Activity�Q�可以把元素的finishOnTaskLaunch讄��?#8220;true”�?br />
http://www.cnblogs.com/xirihanlin/archive/2010/06/03/1750811.html

calvin 2010-11-19 14:32 发表评论

Handler与Android�q�程��理

calvin — Wed, 27 Oct 2010 11:01:00 GMT
     摘要:   阅读全文

calvin 2010-10-27 19:01 发表评论

calvin — Mon, 25 Oct 2010 02:09:00 GMT
1、编译android 代码�?w��i)，�~�译sdk�Q?br /> �~�译注意�Q?br /> 1�Q�gcc的版本过高，�׃��android源码�~�译要求�?.3�Q�如果你的gcc版本�?.4�Q�那你的�~�译可能会失败的�Q�我的系�l�是ubuntu 10.04,默认的gcc版本�?.4�Q�gcc-4.4太严��|��那么怎样从gcc-4.4降到gcc- 4.3呢？
1、安装gcc-4.3
$ sudo apt-get install gcc-4.3 g++-4.3
2、修gcc相关链接
$ cd /usr/bin
$sudo ln -snf gcc-4.3 gcc
$sudo ln -snf g++-4.3 g++
$sudo ln -snf cpp-4.3 cpp

��gcc,g++链接�?.3版本卛_��?br />
2�Q�JDK 5.0, update 12 or higher.Java 6 is not supported, because of incompatibilities with @Override.

3�Q? sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl sun-java5-jdk zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev ia32-libs x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev
参见http://source.android.com/source/download.html

2、拷贝development/ide/eclipse/.classpath�?classpath.

3、启�?eclipse �Q�按照这个步�?File->New->Java Project (不是 Android Project!) ->Create project from existing source 选到代码�?w��i)根目�?.

4、在�l�过长时间等待之后， source code��被导入project�Q�正常情况下应该没有error�?br />
5启动模拟�?br /> [calvin@calvin-desktop ~/android/source-code/android_1.5_Sourcecode 10:28:03 ] $ . build/envsetup.sh
[calvin@calvin-desktop ~/android/source-code/android_1.5_Sourcecode 10:28:18 ] $ lunch 1
[calvin@calvin-desktop ~/android/source-code/android_1.5_Sourcecode 10:30:31 ] $ ./out/host/linux-x86/bin/emulator

6�?strong>在ddms中选中要调试的�q�程

7、在source code中设�|�断�?br />
8、在eclipse�? Run->Debug Configuration->Remote Java Application->New, 讄�� Connection port to 8700 (DDMS’s 默认端口),卛_��正常调试�?br />

calvin 2010-10-25 10:09 发表评论

滚动时显�C�scrollbar

calvin — Mon, 18 Oct 2010 06:25:00 GMT
     摘要:   阅读全文

calvin 2010-10-18 14:25 发表评论

Building, running, and debugging Android source

calvin — Sun, 17 Oct 2010 06:05:00 GMT
     摘要:   阅读全文

calvin 2010-10-17 14:05 发表评论

calvin — Sat, 02 Oct 2010 14:44:00 GMT
     摘要:   阅读全文

calvin 2010-10-02 22:44 发表评论

Android��x��界面代码

calvin — Sat, 02 Oct 2010 13:39:00 GMT
     摘要:   阅读全文

calvin 2010-10-02 21:39 发表评论

calvin — Wed, 29 Sep 2010 13:43:00 GMT
     摘要:   阅读全文

calvin 2010-09-29 21:43 发表评论

国产亚洲精品VA片在线播放,午夜影视日本亚洲欧洲精品一区,亚洲一级黄色大片

[转]不同格式证书导入keystore�Ҏ(gu��)��

Android exchange 账户讄���

setComponentEnabledSetting doesn't work on widget

Activity的onSaveInstanceState调用时机

利用javap生成�Ҏ(gu��)���{�֐�

[转]The Android boot process from power on

Compile CyanogenMod (Linux) for HTC Desire

Android monkey & jni相关

在android工程中导入layoutlib.jar使用internal api

Eclipse 导入gingerbread源代码build path错误

使用git下蝲android源码

SurfaceView与View

android bluetooth

Talking about Android process

[First written by Steve Guo, please keep the mark if forwarding.]

Root Process

Native Application Process

JAVA Application Process

System Server

Persistent Application

The First Activity

Auto-launched Application After Booting

Behind the JAVA process

handler与多�U�程消息处理

Android �H�口���理

[原]Activity启动�q�程分析

PDP context相关

利用onUserLeaveHint发送后台运行通知

[转]Task和Activity相关

Handler与Android�q�程���理

滚动时显�C�scrollbar

Building, running, and debugging Android source

Android��x��界面代码

Android exchange 账户讄��

利用javap生成�Ҏ(gu��)��{�֐�

Android �H�口��理

Handler与Android�q�程��理