android 學習摘要

1、内置應用和開發的應用，沒有差別 

2、Linux Kernel --> Dalvik VM --> Applications 

3、Kernel: 硬體抽象層，同時提供了程序、記憶體、檔案系統管理等核心服務 

   Runtime: Dalvik VM，運作時環境 

   Code libraries: 浏覽器、資料庫、繪圖、影音 

   Managers: Activities、Views、Telephony等管理器 

   Hardware --> Linux Kernel --> Runtime & Libraries --> Application Managers --> Applications 

4、Android基于Linux Kernel，運作在Dalvik VM裡 

5、四種核心元件：Activity、Service、Provider、Receiver 

6、A best practice is to launch Services on a periodic or as-needed basis, triggered by a system alarm, and then have the Service terminate when its task is complete 

7、在manifest.xml檔案裡注冊的Receiver元件，不需要應用啟動，就可以被觸發 

8、每個Android Application跑在一個單獨的程序裡 

9、在OS資源短缺的時候，Application所在的程序，有可能會被kill，不同狀态的程序的優先級有差別 

10、android應用不是跑在jvm裡，而是跑在Dalvik VM裡，所有java位元組碼要轉換成.dex檔案格式 

11、strings這些資源也是被編譯成binary 

12、You can define layout and views directly in code or in a layout XML resource file 

13、you don’t have to use an XML file at all; instead, you can define all your layout and View configuration directly in code, as Java objects. This technique is used in applications where a dynamic GUI is required. Generally speaking, it’s often easier (and better practice) to use an XML layout resource for each Activity. An XML layout file defines View objects, organized into a hierarchical tree structure. After they’re defined in relation to the parent layout,each view can then be inflated at runtime 

14、Android employs a handy adapter concept used to link views that contain collections with an underlying data source 

15、An Adapter is a collection handler that returns each item in the collection as a View 

16、Every process running on the Android platform is placed on a stack. When you use an Activity in the foreground, the system process that hosts that Activity is placed at the top of the stack, and the previous process (the one hosting whatever Activity was previously in the foreground) is moved down one notch 

17、It decides which ones to get rid of based on a simple set of priorities: 

1 The process hosting the foreground Activity is the most important. 

2 Any process hosting a visible but not foreground Activity is next in line. 

3 Any process hosting a background Activity is next in line. 

4 Any process not hosting any Activity (or Service or BroadcastReceiver) is known as an empty process and is last in line. 

18、adb shell dumpsys activity 

19、If the process your Activity is in falls out of the foreground, it’s eligible to be killed and it’s not up to you; it’s up to the platform’s algorithm, based on available resources and relative priorities 

20、 

1 onCreate() 

Called when the Activity is created. Setup is done here. Also provided is access to any previously stored state in the form of a Bundle 

2 onRestart() 

Called if the Activity is being restarted, if it’s still in the stack, rather than starting new 

3 onStart() 

Called when the Activity is becoming visible on the screen to the user 

4 onResume() 

Called when the Activity starts interacting with the user (This method is always called, whether starting or restarting) 

5 onPause() 

Called when the Activity is pausing or reclaiming CPU and other resources. This method is where you should save state information so that when an Activity is restarted, it can start from the same state it was in when it quit 

6 onStop() 

Called to stop the Activity and transition it to a nonvisible phase and subsequent 

lifecycle events 

7 onDestroy() 

Called when an Activity is being completely removed from system memory. This method is called either because onFinish() is directly invoked or the system decides to stop the Activity to free up resources 

21、it’s important to know that onPause() is the last opportunity you have to clean up and save state information. The processes that host your Activity classes won’t be killed by the platform until after the onPause() method has completed, but they might be killed thereafter 

22、The system will attempt to run through all of the lifecycle methods every time, but if resources are spiraling out of control, as determined by the platform, a fire alarm might be sounded and the processes that are hosting activities that are beyond the onPause() method might be killed at any point 

23、In addition to persistent state, you should be familiar with one more scenario: instance state. Instance state refers to the state of the UI itself. The onSaveInstanceState()method is called when an Activity might be destroyed, so that at a future time the interface state can be restored 

24、耗時比較多的工作，應該在UI Thread之外完成，實作的方法是使用Handler類 

25、android支援自定義View元件 

26、In Android, screen layout is defined in terms of ViewGroup and 

LayoutParams objects. ViewGroup is a View that contains other views (has children) and also defines and provides access to the layout

--------------------------------------------------------------------------

一、Each Activity can make an Intent call to get something done without knowing exactly who’ll receive that Intent 

Android的這種調用方式，是一種各元件之間低耦合的內建方式。比如自己的應用需要調用打電話的功能，可以建立一個Intent.setAction(DIAL)，請求“某一個”電話程式來完成打電話功能。如果沒有安裝第三方的程式，那麼通常手機自帶的電話程式會響應這個請求，如果安裝了第三方的撥号程式（當然這種情況很少），那麼就會由第三方撥号程式完成通話。而原來的Activity，對這一切是一無所知的 

二、用intent來描述意圖，然後用intent-filter來進行全局比對。如果找到唯一結果，就進行調用；如果找到多個結果，則要求使用者選擇；如果沒有找到結果，則抛出異常。手機上安裝的所有程式，無論是自帶的，還是第三方應用，都會參與這個比對過程。當然，如果在manifest.xml中沒有設定intent-filter，就不會參與到intent比對。這種情況下，這種元件就隻能通過顯式調用被調用到 

三、 

Action:     Fully qualified String indicating the action (for example, android.intent.action.DIAL) 

Category:   Describes where and how the Intent can be used, such as from the main 

            Android menu or from the browser 

Component:  Specifies an explicit package and class to use for the Intent, instead of inferring from action, type, and categories 

Data:       Data to work with, expressed as a URI (for example, content://contacts/1) 

Extras:     Extra data to pass to the Intent in the form of a Bundle 

Type:       Specifies an explicit MIME type, such as text/plain or vnd.android.cursor.item/email_v2 

四、implicit and explicit invocation。這個說的是隐式調用和顯式調用 

五、Android parses each <intent-filter> element into an IntentFilter object. After Android installs an .apk file, it registers the application’s components, including the Intent filters. When the platform has a registry of Intent filters, it can map any Intent requests to the correct, installed Activity, BroadcastReceiver, or Service 

六、下面是intent-filter的比對規則 

Action: Each individual IntentFilter can specify zero or more actions and zero or more categories. If the action isn’t specified in the IntentFilter, it’ll match any Intent; otherwise, it’ll match only if the Intent has the same action 

Category: An IntentFilter with no categories will match only an Intent with no categories; otherwise, an IntentFilter must have at least what the Intent specifies. For example,if an IntentFilter supports both the HOME and the ALTERNATIVE categories, it’ll match an Intent for either HOME or CATEGORY. But if the IntentFilter doesn’t provide any categories, it won’t match HOME or CATEGORY 

Data: scheme://authority/path分别對應android:schema、android:host、android:path 

七、A broadcast Intent doesn’t invoke an Activity, so your current screen usually remains in the foreground 

八、Android best practices discourage long-running services. Services that run continually and constantly use the network or perform CPU-intensive tasks will eat up the device’s battery life and might slow down other operations 

九、In Android, each application runs within its own process. Other applications can’t directly call methods on some service of another application, because the applications are in different sandboxes 

十、If you want to allow other developers to use your weather features, you need to give them information about the methods you provide, but you might not want to share your application’s source code. Android lets you specify your IPC features by using an interface definition language (IDL) to create AIDL files 

十一、Service lifecycle 

SERVICE-STARTED LIFECYCLE: If you start a Service by calling Context.startService(), it runs in the background whether or not anything binds to it. If the service hasn’t been created, the Service onCreate() method is called. The onStart() method is called each time someone tries to start the service, whether or not it’s already running. Additional instances of the Service won’t be created. The Service will continue to run in the background until someone explicitly stops it with the Context.stopService() method or when the Service calls its own stopSelf() method. You should also keep in mind that the platform might kill services if resources are running low, so your application needs to be able to react accordingly 

SERVICE-BOUND LIFECYCLE: If an Activity binds a Service by calling Context.bindService(), it’ll run as long 

as the connection is open. An Activity establishes the connection using the Context and is also responsible for closing it. When a Service is only bound in this manner and not also started, its onCreate() method is invoked, but onStart() is not used. In these cases, the platform can stop and clean up the Service after it’s unbound 

CLEANING UP WHEN A SERVICE STOPS: When a Service stops, its onDestroy() method is invoked. Inside onDestroy(), every Service should perform final cleanup, stopping any spawned threads, terminating network connections, stopping services it had started, and so on

------------------------------------------------------------------------------------------------------------

1、Activity和Service元件是Context的子類，BroadcastReceiver和ContentProvider不是 

2、用adb shell指令，可以看到底層linux的目錄結構 

data/anr 記錄ANR資訊 

data/app/*.apk 應用的安裝源檔案 

data/data/package_name 裝好的應用會出現在這裡，package_name取決于Manifest.xml檔案中的定義 

data/data/package_name/shared_prefs/name.xml SharedPreferences檔案會儲存在這裡 

data/data/package_name/files/file.name 用openFileOnput()建立的檔案在這裡 

data/data/package_name/databases/dbname.db 内置的SQLite資料庫檔案在這裡，如果沒有這個檔案，就會觸發SQLiteOpenHelper類的onCreate()方法 

3、利用SharedPreferences來存儲鍵值對 

   Context.MODE_PRIVATE 0 

   Context.MODE_WORLD_READABLE 1 

   Context.MODE_WORLD_WRITEABLE 2 

建立的檔案在這個路徑：shared_prefs/name.xml 

4、用Context的createPackageContext()方法，可以得到另外一個應用的Context，不過前提是你得知道另外一個應用的package_name，但是别人如果不告訴你，你一般是不會知道的 

Context.createPackageContext(String packageName,Context.MODE_WORLD_READABLE) 

5、SharedPreferences are ultimately backed by XML files on the Android filesystem 

6、Context.openFileOutput(String fileName,Context.MODE_PRIVATE); 

建立的檔案儲存在files/file.name 

7、Context.openFileInput(String fileName,Contet.MODE_PRIVATE); 

8、Occasionally, setting the user ID of your application can be extremely useful. For instance, if you have multiple applications that need to share data with one another, but you also don’t want that data to be accessible outside that group of applications, you might want to make the permissions private and share the UID to allow access. You can allow a shared UID by using the sharedUserId attribute in your manifest: android:sharedUserId="YourID". 

9、When you place a file in the res/raw location, it’s not compiled by the platform, but is available as a raw resource 

10、Files in res/xml are different from raw files in that you don’t use a stream to access them because they’re compiled into an efficient binary form when deployed. 

11、The SD card is removable, and SD card support on most devices (including Android-powered devices) supports the File Allocation Table (FAT) ) filesystem. The SD card doesn’t have the access modes and permissions that come from the Linux filesystem. 

12、要用好Android内置的SQLite，首先需要熟練掌握下面4個類的用法 

SQLiteOpenHelper 

SQLiteDatabase 

ContentValues 

Cursor 

13、Unlike the SharedPreferences you saw earlier, you can’t make a database WORLD_READABLE. Each database is accessible only by the package in which it was created. If you need to pass data across processes, you can use AIDL/Binder or create a ContentProvider, but you can’t use a database directly across the process/package boundary. 

14、内置的SQLite資料庫，可以用 

adb shell 

cd data/data/package_name/databases 

sqlite3 name.db 

來通路，在這個指令行界面，可以使用很多指令，有一個比較友善的是.header ON，可以在用select語句的時候，列印出列明。不然什麼都看不到，因為預設的是.header OFF 

15、ContentProvider可以跨應用通路資料庫 

16、用完Cursor之前，不能調用SQLiteDatabase.close();否則Cursor就失效了，為了這個低級錯誤，浪費了很多時間調試代碼。。。不過最終寫了一個還算不錯的通用資料庫通路層，可以支援簡單的ORM和跨表事務。代碼在公司，周一再專門寫一篇部落格發出來 

17、SQLiteDatabase.insert()中用到的ContentValues不包含autoincrement的_id，這個也是低級錯誤。。也研究了好長時間 

18、單元測試繼承自AndroidTestCase，裡面有一個getContext() 

19、MainActivity.this，這個一般常出現在OnClickListener的onClick()方法體裡，因為OnClickListener在這個場景裡常常是作為一個内部類出現，是以MainActivity.this，指的就是所在的MainActivity對象的引用 

20、Cursor用完要關閉哦，親，不是隻關DB就可以的 

21、如果一個Receiver要同時偵聽好多事件，可以在onReceive()方法裡用intent.getAction()來判斷觸發的是哪個事件 

22、偵聽網絡變化用ConnectivityManager，而不是TelephonyManager，因為可能會捕獲到2次OFF_LINE事件 

public class NetworkChangeReceiver extends BroadcastReceiver {  

    @Override  

    public void onReceive(Context context, Intent intent) {  

        ConnectivityManager cm = (ConnectivityManager) context  

                .getSystemService(Context.CONNECTIVITY_SERVICE);  

        NetworkInfo status = cm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);  

        if (status.isConnected()) {  

            Log.i("tag", "網絡可用");  

        } else {  

            Log.i("tag", "網絡不可用");  

        }  

    }  

}  

<application android:icon="@drawable/icon" android:label="@string/app_name">  

        <receiver android:name=".receiver.NetworkChangeReceiver">  

            <intent-filter>  

                <action android:name="android.net.conn.CONNECTIVITY_CHANGE" />  

            </intent-filter>  

        </receiver>  

    </application>  

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