本文章採用 Markdown 語法撰寫，若無法完整閱讀全文，請點擊這裡。

• 2017.10.23 UPDATE: The paper can be download at the LD-DL workshop website.

本文章採用 Markdown 語法撰寫，若無法完整閱讀全文，請點擊這裡。

本文章採用 Markdown 語法撰寫，若無法完整閱讀全文，請點擊這裡。

本文章採用 Markdown 語法撰寫，若無法完整閱讀全文，請點擊這裡。

本文章採用 Markdown 語法撰寫，若無法完整閱讀全文，請點擊這裡。

本文章採用 Markdown 語法撰寫，若無法完整閱讀全文，請點擊這裡。

本文章採用 Markdown 語法撰寫，若無法完整閱讀全文，請點擊這裡。

本文章採用 Markdown 語法撰寫，若無法完整閱讀全文，請點擊這裡。

本文章採用 Markdown 語法撰寫（why?），若無法完整閱讀全文，請點擊這裡。

Please follow this link if you are unable to read this article. ]]> tag:www.jollen.org,2016:/blog//2.850 2016-01-27T11:02:30Z 2016-03-10T11:32:35Z

本文章採用 Markdown 語法撰寫（why?），若無法完整閱讀全文，請點擊這裡。

本文章採用 Markdown 語法撰寫（why?），若無法完整閱讀全文，請點擊這裡。

為了在 NodeMCU 上進行 WoT 實驗，日前開啟了一個小型的專案 node-wot，node-wot 將會持續小幅修改 nodemcu-firmware，以做為 WoT 的實驗用 firmware。

本文章採用 Markdown 語法撰寫（why?），若無法閱讀內文，請點擊這裡。

寫作文

參考資源

註：本文節錄自「Node.js & HTML5 開發思惟與入門學習」一書，並原文重現。

本章的目標，是提昇初學者的開發功力。經過前面 4 個章節的介紹，學習到許多基本觀念與技術。接下來，將從三個不同的層面，深化目前所學到的觀念與技術：

• JavaScript 語言
• Web Service 架構
• Node.js 觀念

本章先從 JavaScript 語言開始。JavaScript 最重要的觀念是 Closure，這可以說是 JavaScript 初學者的第 1 堂。Closure 與暱名函數有很緊密的關係，這要由 Lambda 的觀念開始講起。

Lambda

Lambda（λ）是一個希臘字母（Λ 是它的大寫字母），用來表示許多觀念：

• 物理學家用來表示波長的符號
• 數學家用來表示空字串的符號
• 電腦科學家用來表示暱名函數（Anonymous Function）的符號

Lambda 在電腦科學領域，用來表示暱名函數，目的是進行運算。為了尋找一個語法簡易的運算表示方式，電腦科學家會這麼做。

Step 1：取得一個具名的函數

例如一個加法函數：

sum(x) = x + 2

函數 sum() 是具名函數，利用 JavaScript 來實作的話，寫法如下：

function sum(x) {
     return x + 2;
}

Step 2：改寫為暱名函數

Lambda 希望可以找到一個能運算的表示方法，而且要簡單，去除掉函數名稱，就是一個方式。沒有具體名稱的函數，就稱為暱名函數（Anonymous Function）。如果表示暱名函數呢？上述範例，以 Lambda 來表示的話，只要改寫成：

λx.x + 2

用 JavaScript 來實作的話，要如何撰寫呢？方式如下：

(function(x) {
     return x + 2;
})();

這就是第 1 章介紹的 Closure 觀念，最後加上的一對括號，稱為立即函數，意思是立即執行此暱名函數的意思。立即函數，以物件導向的角度來看，也可以解釋為立即實例化。

Step 3：使用 var 來宣告暱名函數

JavaScript 的 var 關鍵字用來宣告變數，所以也可以把暱名函數做為運算子（Operator）來宣告變數。例如：

var lambda = (function(x) {
     return x + 2;
})();

變數 lambda 被指定（Assign）為一個暱名函數。從 JavaScript 語言的角度來看，Closure 用來封裝出 Module，所以 lambda 變數也可以解釋成「一個模組」。宣告一個暱名函數的變數時，可以不需要 Closure。也可以採用以下的寫法：

var lambda = function(x) {
     return x + 2;
};

事實上，這個寫法更為普遍。一些文章也把這種寫法，稱做 Function Expressions。

有一個重要的觀念要釐清，上述的寫法，正規的解釋方式是「宣告暱名函數的變數」，所以 lambda 是一個變數，不能解釋為函數。如果說 lambda 是一個函數宣告，觀念上就不對了。不能單就 JavaScript 語法的角度來做解釋。

以 JavaScript 來說，函數宣告的寫法為：

function lambda(x) {
     return x + 2;
};

這個時候，lambda 就是一個函數。那一種寫法比較好呢？理論上，採用暱名函數宣告的方式較佳，因為 JavaScript 本身是一種 Lambda 的程式語言。

Callback Function

Lambda 本質上是一種表示方法，用來表示 Input 與 Output。所以，要表示一個平方的運算的話，寫法如下：

λx.x*x

這個運算式，也可以做為另一個 Lambda 式子的 Input，請看以下的說明。

Step 1：撰寫第一個計算平方的 Lambda 表示式

做法如下：

λx.x*x

Step 2：把上述的式子做為另一個 Lambda 的輸入

有一個 f(x) = x + 2 的函數，用 Lambda 來表示的話，寫法如下：

(λx.x+2)

如果要把 Step 1 的結果，做當上面式子的 x（輸入），合併後的寫法為：

(λx.x*x)(λx.x+2)

讓我們來筆算看看：

• x = 3 時，λx.x*x 的 Output 為 9
• 9 做為 λx.x+2 的 Input，成為 9 + 2，Output 為 11
• 答案就是 11

(λx.x*x)(λx.x+2) 等價於 9 + 2。

Step 3：使用 JavaScript 來實作

怎麼把 (λx.x*x)(λx.x+2) 寫成程式碼呢？非常簡單，由於 Output 就是返回值，所以等於「讓暱名函數的返回值，當做另一個暱名函數的參數」。程式碼如下：

var lambda = function(x) { return x + 2 };
var result = lambda(function(x) { return x * x} (3) );

console.log("Result: " + result);

這個輸出的輸出結果為 11。這可不是在賣弄程式碼，而是實現出 (λx.x*x)(λx.x+2) 這個 Lambda 演算。以暱名函數來表示 Lambda 是很常見的做法，但其實反應出 JavaScript 語法上的不足。如果能有一個更簡易的語法，讓我們表示 Lambda，這段程式碼就會比較精簡。

所以，這很可能要從修改 JavaScript 語法的角度，來做強化。未來，新的 ECMAScript（JavaScript 的語法標準）或許可以讓我們這樣寫程式：

function(x) { return x + 2 }  // 複雜的寫法
x => x + 2                            // 希望可以有這種精簡的語法

再舉一個例子：

var result = (x => x * x) 3;  // 左結合寫法，輸入值 3 放在最右邊，最後 result 為 9

如果將 Lambda 做為函數的參數：

[1, 2, 3, 4, 5]
     .map(function(x) { return x * x });

未來或許能簡化為：

[1, 2, 3, 4, 5]
     .map(x => x * x);             // 希望可以有這種精簡的語法

在 ECMAScript 還沒有正式加入相關語法前，我們目前還是只能使用暱名函數的寫法。

使用 TypeScript

在深入了解 Lambda 的觀念後，就能知道根本之道在於「新的 JavaScript 語法」。目前有一些 Open Source 程式庫，就試著在解決這個問題。唯有透徹底了解 Lambda 的觀念，才能知道這些程式庫目地何在。

筆者推薦的解決方案是：TypeScript。這是一個由 Microsoft 所開發的工具，實際上是一個 Compiler。TypeScript 提供了擴充的 JavaScript 語法，可藉由 TypeScript 編譯為標準的 JavaScript 語法。

首先，必須先使用 npm 安裝 TypeScript 工具：

$ npm install -g typescript

接著，以 TypeScript 的語法撰寫 JavaScript 程式碼。TypeScript 的語法就是 JavaScript 語法，只是提供了許多好用的擴充語言，因此學習上並沒有障礙。以下是一個 TypeScript 範例：

var square = (x) => x * x
console.log(square(3));

將程式碼儲存為 l.ts 後，再利用 TypeScript 編譯：

$ tsc l.ts

編譯後可以得到 l.js 檔案，以下是 l.js 的內容：

var square = function (x) {
    return x * x;
};
console.log(square(3));

看到編譯後的程式碼後，馬上可以反應出這個觀念：TypeScript 提供一個簡單好用的 Lambda 語法。當然，TypeScript 的功能很豐富，這只是牛刀小試。

1287 sp<ISurface> SurfaceFlinger::createSurface(
1288         ISurfaceComposerClient::surface_data_t* params,
1289         const String8& name,
1290         const sp<Client>& client,
1291         DisplayID d, uint32_t w, uint32_t h, PixelFormat format,
1292         uint32_t flags)

0 1 qcom

1303     //LOGD("createSurface for pid %d (%d x %d)", pid, w, h);
1304     sp<Layer> normalLayer;
1305     switch (flags & eFXSurfaceMask) {
1306         case eFXSurfaceNormal:
1307             normalLayer = createNormalSurface(client, d, w, h, flags, format);
1308             layer = normalLayer;
1309             break;
1310         case eFXSurfaceBlur:
1311             // for now we treat Blur as Dim, until we can implement it
1312             // efficiently.
1313         case eFXSurfaceDim:                                                
1314             layer = createDimSurface(client, d, w, h, flags);
1315             break;
1316         case eFXSurfaceScreenshot:
1317             layer = createScreenshotSurface(client, d, w, h, flags);
1318             break;
1319     }

• 開放平臺為戰略的軟體研發結構？企業管理技術的一環。

• 繁華再見後，手機業經營者挑戰巨大。至少別再衝浪了。

struct led_module_t {
   struct hw_module_t parent;
};

宏達電(HTC)在2010年MWC推出HTC Desire時，獲得相當不錯的迴響，網路上紛紛以「最強的Android手機」來評價它。當時的三星，在Android手機領域，完全沒有任何建樹。即使是今年震撼MWC的華為(Huawei)，或是令人刮目相看的中興(ZTE)，當年推出的Android手機完全無法與HTC Desire抗衡。在硬體規格上落後HTC一大截。

HTC一向都是領先的硬體技術者，在2011 MWC推出Incredible S時，硬體技術仍舊領先業界；今年的MWC，繼續以HTC One X保持領先的硬體技術。HTC One系列更再加碼，以自有的ImageSense軟硬體技術，把手機照像功能再推上一層樓。仕橙部落特別將HTC過去三年來的MWC主打機，做了一個整理。

製表：仕橙部落

從這張表可以發現，HTC在2010年時，硬體技術可說是大幅領先同業，以華為來說，當年所推出的機種，應用處理器也只有528MHz，螢幕規格更差了一大截。到了2011年，HTC Incredible S仍舊領先競爭對手，不過差距已經縮小許多。

到了今年，大家從媒體的報導就可以看得出來，HTC One X已經沒有硬體技術的優勢了；除了ImageSense外，華為與中興都已經和HTC並駕齊驅。

製表：仕橙部落

這倒是給了我們一個警示。2010年到2012年，實質上只有二個整年；華為與中興從大幅落後，到現在迎頭趕上，只花了730天的時間。這說明了，如果2013 MWC還是主打硬體規格，競爭對手之間，已經沒有任何差異性了；就像 [HTC新機功能強大　仍缺”獨賣”價值] 提到的：

分析師指出，雖然HTC在這次大會中證實自己仍是手機硬體技術的領導品牌廠，但這並不足以成為強大的競爭優勢，因為這些門檻別人很快就會跨越追上。

筆者的看法很簡單，HTC已經不需要向誰證明它的硬體技術，或是製造能力了，專注思考「差異化的價值」，一定能做得非常不錯。如果不認真去思考什麼是差異化的價值，那可能完全想不透，為什麼Samsung Galaxy SII能獲得如此迅速又巨大的成功；這可不是因為AMOLED面板被斷貨，這麼簡單的原因。而且，用什麼作業系統，對HTC來說也不是很重要的事情，也不必去再乎Bada作業系統的潛在影響力。

我們知道，雲端應用目前有二大龍頭：Google與Facebook。Google老大哥的Gmail、相簿、位置服務等，儼然成為一項民生必須品。Facebook則是在社交網路(Social Networking)領域獨佔鰲頭。他們都是網路巨擎，也都是以平臺(Platform)的概念經營。平臺的概念是什麼？簡單說，就是提供開發者API服務。

平臺是一個很容易理解的概念，就像大家手上的手機，裡頭安裝了許多使用到Google以及Facebook API的App；這些App都會透過「雲端」，存取其服務。iPhone與Android手機裡的這些「雲端App」，所使用到的核心技術，就是HTML5。這代表著，只要HTML5的規格能開始推出草案(Draft)，並且手機上的HTML5瀏覽器技術更加成熟，手機行業將會展開一場HTML5大戰。HTML5大戰就是雲端運算的戰爭，這肯定是新一波的軟體革命。以HTML5技術，結合網路服務、開發App，並整合至手機，將成為顯學。

所以，筆者認為，Android版Chrome的到來，從產業的角度來看，肯定是一個重要指標，具有特別的意義。它將帶領HTML5往前衝刺。其實，Chrome很早就是HTML5的領頭羊了，例如：早在2010年，Google就宣佈以HTML5取代Google Gear技術，從這裡可見一斑。

我們可以這樣假設：有了Chrome，雲(Cloud Computing)就更容易放進裝置裡。正因為如此，所以Chrome的出現，有了HTML5大戰的煙焇味。Chrome將加速雲端應用走進手機App，所以手機不能只有硬體功能，硬體廠將面臨新的一波挑戰。

This ought to be the era of the software developer.

「這應該是軟體人的時代」

Every week sees a new event courting the lowly hacker. Here are a few recent examples from my day timer: The Android Dev Con, ARM Tech Con, Blackberry Dev Con, Ubuntu Dev Con…and the list goes on.

「每週，都有很多活動，想要拉攏軟體高手，像是 Android Dev Con、ARM Tech Con、Blackberry Dev Con、UBuntu Dev Con。」

Even Taiwan's notebook makers are hungry for all the low level software architects they can find—especially those who can help them customize Android kernels for their future smartphones and tablets.

So, software developers, today is your day to unite. You have nothing to lose but your shackles.

「所以，軟體人，今天是你們要團結的日子，你們沒有什麼包袱，只要解開你的桎梏」

intArraryAdd(JNIEnv *env, jobject obj, jintArray arr)
 {
     jint buf[10];
     jint i, sum = 0;
　
     (*env)->GetIntArrayRegion(env, arr, 0, 10, buf);
　
     for (i = 0; i < 10; i++) {
         sum += buf[i];
     }
     return sum;
 }

• 1. Permissive License
• 2. Weak Copyleft
• 3. Strong Copyleft

Message msg = Message.obtain();

Return a new Message instance from the global pool. Allows us to avoid allocating new objects in many cases. (--Android SDK Reference)

	public boolean onKeyDown(int keyCode, KeyEvent event) {
		...
		mHandler.sendMessage(Message.obtain()); // 可避免產生不必要的物件
		...
	}

• Activity.runOnUiThread(Runnable)
• View.post(Runnable)
• View.postDelayed(Runnable, long)

多項重要技術的推出，讓Honeycomb成為真正的平板電腦作業系統。

• Service Layer 屬於 Application Framework 層，提供 Application 存取硬體的「服務」。理論上，這些服務是以 instance 的形式存在。
• Hardware Abstraction Layer 介於 Application Framework 與 Driver Framework 之間，以抽象形式存取硬體。理論上，HAL 層的存在形式有三種 - library (module) / server / communication bus。
• Native Servier 屬於整個 Android 作業系統最底層。理論上，它應該在 HAL 層之下，也是 HAL 不會是我們想像中「隔絕 kernel 的最下層」，存在形式為 daemon。
• Driver Framework 屬於 kernel-space 層，也就是包含在 Linux kernel 裡，「非常 long-term 來看」也可以是其它 OS。理論上，Driver Framework 是以 instance 的形式存在。

public class MusicPlayerUI extends Activity implements OnClickListener {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
　
        Button playBtn = (Button) findViewById(R.id.playBtn);
        Button stopBtn = (Button) findViewById(R.id.playBtn);
　
        playBtn.setOnClickListener(this);
        stopBtn.setOnClickListener(this);
    }
　
	public void onClick(View v) {
		Access Audio Hardware and get it ready.
		Control Audio Hardware and start music.
	}
}

public class MusicPlayerUI extends Activity implements OnClickListener {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
　
        Button playBtn = (Button) findViewById(R.id.playBtn);
        Button stopBtn = (Button) findViewById(R.id.playBtn);
　
        playBtn.setOnClickListener(this);
        stopBtn.setOnClickListener(this);
    }
　
	public void onClick(View v) {
		// TODO Auto-generated method stub
		MediaPlayer p = MediaPlayer.create(this, R.raw.test);
		p.start();
	}
}

jollen@android:~/try/mokoid_elcair-20100511$ touch system/core/init/init.c
jollen@android:~/try/mokoid_elcair-20100511$ . build/envsetup.sh 
including vendor/aosp/vendorsetup.sh
jollen@android:~/try/mokoid_elcair-20100511$ m INIT_BOOTCHART=true PRODUCT-dma6410xp-eng -j 8
============================================
PLATFORM_VERSION_CODENAME=REL
PLATFORM_VERSION=2.1-update1
TARGET_PRODUCT=dma6410xp
TARGET_BUILD_VARIANT=eng
TARGET_SIMULATOR=
TARGET_BUILD_TYPE=release
TARGET_ARCH=arm
HOST_ARCH=x86
HOST_OS=linux
HOST_BUILD_TYPE=release
BUILD_ID=ECLAIR
============================================

$ adb shell 'echo 120 > /data/bootchart-start'
$ adb shell 'mkdir /data/bootchart'

linux@android:~/android/mokoid$ adb shell
# ls -l /data/bootchart
-rw-rw-rw- root     root          389 2010-07-28 11:06 header
-rw-r--r-- root     root            0 2010-07-28 11:06 kernel_pacct
-rwxr-xr-x root     root       589824 2010-07-28 11:08 proc_diskstats.log
-rwxr-xr-x root     root      2293760 2010-07-28 11:08 proc_ps.log
-rwxr-xr-x root     root       196608 2010-07-28 11:07 proc_stat.log
# 

linux@android:~/android/mokoid$ cd system/core/init/
linux@android:~/android/mokoid/system/core/init$ ./grab-bootchart.sh 
7 KB/s (389 bytes in 0.048s)
1439 KB/s (405771 bytes in 0.275s)
2014 KB/s (3861856 bytes in 1.872s)
1936 KB/s (979391 bytes in 0.493s)
look at bootchart.tgz

$ sudo apt-get install bootchart

$ java -jar /usr/share/bootchart/bootchart.jar /tmp/android-bootchart/bootchart.tgz
Parsing /tmp/android-bootchart/bootchart.tgz
Wrote image: ./bootchart.png

Rinascimento, FOSS or FLOSS (free/libre/open source software)

神權至上的時期，被稱為「黑暗時期」，在 14 世紀興起的「文藝復興」運動，打破這個現象。也就是說，黑暗時代，神權至上，可能有很多像是「魔法」的東西，或是很多霍格華茲魔法學校（註：哈利波特的學校）；文藝復興後，很多近代科學開始發展，生活在此時期後的人類，哈利波特稱之為麻瓜（Muggle，指沒有魔法的人）。

在 13 世紀晚期，義大利中產階段因為生活上的富足，開始尋求更優雅與時尚的生活，於是萠生「脫離神權」的想法。知名詩人「但丁（1265-1321）」的出現，被認為是義大利文藝復興時代的開始。於是，「個人主義」，也就是文藝復興運動的重要產物之一，開始發展。許多耳熟能詳的「大師」，也在文藝復興時期開始出現，例如：米開朗基羅（忍者龜）；天文學、物理學、數學、生物學等，高中時期最令我頭痛的近代科學，有了重要的發展。

用近代的網路現象來比喻，文藝復興運動很像是 Web 2.0。出現很多新現象，例如：個人主義的興起，每個人都可以自由創作，發表成果，這裡的「個人主義」指的是「好的」個人主義，例如：分享、討論、知識交換，而不是自私的這種個人主義。

文藝復興時期，經典創作「聖彼得大教堂」花了 120 年的時間建造，由多位大師共同創作而成，很像是 Web 2.0 時代的「共筆」或是「協作」。Linux kernel 是網際網路時代，社群協作的重要創作之一。今天我們使用的 Android 手機，都是運行於 Linux kernel 軟體之上。

聖彼得大教堂，肯定是背包客必定點名的景點，這是天主教最神聖的地方。聖彼得大教堂花了這麼久的時間才完工，當然不可能是由同一位建築師獨立完成，參與聖彼得大教堂設計的建築師有勃拉芒特、拉斐爾、米開朗基羅、小莎迦洛，這也是聖彼得大教堂的特色；現今，自由軟體界，稱重要且具代表性的 developer 為「大神」。感謝以上四位大神的共同協作，讓我們在 700 年後的今天，能親眼目睹這個偉大的建築，能欣賞到令人嘆為觀止的繪畫與雕刻。

文藝復興運動，就像 Internet/WWW 的出現，以及後來的 Web 2.0 與開放源碼運動（Open Source Movement）一樣，影響全人類的生活與文化發展。近年來，手機也從封閉走向開放，以及「個人創作手機軟體」的運動發展，相信只要再 1~2 年的時間，我們的生活與文化，都會產生很大的改變。

自由軟體，打破「軟體黑暗時期」；每個人都能在手機上創作內容，也將打破「手機黑暗時期」。軟體黑暗時期？據可靠資料，可能指微x時期。

註1：這句話來自於 Richard M. Stallman 大師，對於自由軟體的自由「Free」之 [解釋]。

/* * Copyright (C) 2010 The Mokoid Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define LOG_TAG "LED Stub" #include <stdlib.h> #include <string.h> #include <unistd.h> #include <assert.h> #include <jni.h> #include <mokoid/led.h> #include <cutils/properties.h> #define HAL_DEFAULT_VARIANT "default" static const char *variant_keys[] = { "ro.hardware", /* This goes first so that it can pick up a different file on the emulator. */ "ro.product.board", "ro.board.platform", "ro.arch" }; #define HAL_VARIANT_KEYS_COUNT (sizeof(variant_keys)/sizeof(variant_keys[0])) int main() { int i; int status; char prop[PATH_MAX]; status = -EINVAL; for (i = 0; (status != 0) && (i < HAL_VARIANT_KEYS_COUNT); i++) { if (property_get(variant_keys[i], prop, NULL) == 0) { continue; } printf("Your property is: %s = %s\n", variant_keys[i], prop); } return 0; }

• ro.hardware
• ro.product.board
• ro.board.platform
• ro.arch

$ svn co http://mokoid.googlecode.com/svn/trunk/ mokoid

$ cp frameworks/base/services/jni/com_android_server_BatteryService.cpp /tmp

$ cd <path-to-your-android-source>/
$ repo sync

$ cp /tmp/com_android_server_BatteryService.cpp frameworks/base/services/jni/com_android_server_BatteryService.cpp

$ make PRODUCT-dma6410xp-eng

$ mkimage -A arm -O linux -T ramdisk -C none -a 0x50800000 -n "ramdisk" -d ramdisk.img ramdisk-uboot.img

U-Boot 1.1.6 (Jan 21 2010 - 08:58:14) for SMDK6410                              
                                                                                
                                                                                
CPU:     S3C6410@666MHz                                                         
         Fclk = 666MHz, Hclk = 166MHz, Pclk = 83MHz, Serial = CLKUART (ASYNC Mo 
Board:   SMDK6410                                                               
DRAM:    128 MB                                                                 
Flash:   0 kB                                                                   
NAND:    128 MB                                                                 
In:      serial                                                                 
Out:     serial                                                                 
Err:     serial                                                                 
Initialise LCD with values                                                      
Hit any key to stop autoboot:  0                                                
SMDK6410 # run system                                                           
dm9000 i/o: 0x30000300, id: 0x90000a46                                          
MAC: 00:40:5c:26:0a:5b                                                          
could not establish link                                                        
TFTP from server 10.0.1.24; our IP address is 10.0.1.25                         
Filename 'system.img'.                                                          
Load address: 0x50008000                                                        
Loading: T ####################################
...
done                                                                            
Bytes transferred = 59174016 (386ec80 hex)                                      
                                                                                
NAND erase: device 0 offset 0xa00000, size 0x4300000                            
Erasing at 0x4ce0000 -- 100% complete.                                          
OK                                                                              
                                                                                
NAND write: device 0 offset 0xa00000, size 0x386ec80                            
                                                                                
Writing data at 0x40b8800 -- 100% complete.                                     
 59174016 bytes written: OK       
SMDK6410 # run ramdisk_uboot                                                    
dm9000 i/o: 0x30000300, id: 0x90000a46                                          
MAC: 00:40:5c:26:0a:5b                                                          
could not establish link                                                        
TFTP from server 10.0.1.24; our IP address is 10.0.1.25                         
Filename 'ramdisk-uboot.img'.                                                   
Load address: 0x50008000                                                        
Loading: ################################                                       
done                                                                            
Bytes transferred = 158894 (26cae hex)                                          
                                                                                
NAND erase: device 0 offset 0x900000, size 0x100000                             
Erasing at 0x9e0000 -- 100% complete.                                           
OK                                                                              
                                                                                
NAND write: device 0 offset 0x900000, size 0x100000                             
 1048576 bytes written: OK          

/*
 * Copyright (C) 2009 Mokoid Open Source Project
 * Copyright (C) 2009 Moko365 Inc
 * 
 * Author: Jollen Chen <jollen@jollen.org>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#define LOG_TAG "MokoidLedStub"
 
#include <hardware/hardware.h>
 
#include <fcntl.h>
#include <errno.h>
 
#include <cutils/log.h>
#include <cutils/atomic.h>
 
#include <mokoid/led.h>
 
/**
 * Definition of kernel-space driver.
 */
#define	LED_DEVICE	"/dev/led"
#define	LED_C608	1
#define	LED_C609	2
 
static int led_device_close(struct hw_device_t* device)
{
	struct led_control_device_t* ctx = (struct led_control_device_t*)device;
 
	if (ctx) {
		close(ctx->fd);
		free(ctx);
	}
	return 0;
}
 
static int led_on(struct led_control_device_t *dev, int32_t led)
{
	int fd;
 
	LOGI("LED Stub: set %d on.", led);
	fd = dev->fd;
 
	switch (led) {
		case LED_C608: 
			ioctl(fd, 1, &led);
			break;
		case LED_C609:
			ioctl(fd, 1, &led);
			break;
		default:
			return -1;
	}
 
	return 0;
}
 
static int led_off(struct led_control_device_t *dev, int32_t led)
{
	int fd;
 
	LOGI("LED Stub: set %d off.", led);
	fd = dev->fd;
 
	switch (led) {
		case LED_C608: 
			ioctl(fd, 2, &led);
			break;
		case LED_C609:
			ioctl(fd, 2, &led);
			break;
		default:
			return -1;
	}
 
	return 0;
}
 
static int led_device_open(const struct hw_module_t* module, const char* name,
        struct hw_device_t** device) 
{
	struct led_control_device_t *dev;
 
	dev = (struct led_control_device_t *)malloc(sizeof(*dev));
	memset(dev, 0, sizeof(*dev));
 
	dev->common.tag =  HARDWARE_DEVICE_TAG;
	dev->common.version = 0;
	dev->common.module = module;
	dev->common.close = led_device_close;
 
	dev->set_on = led_on;
	dev->set_off = led_off;
 
	*device = &dev->common;
 
	/*
         * Initialize Led hardware here.
         */
        dev->fd = open(LED_DEVICE, O_RDONLY);
	if (dev->fd < 0) 
	    dev->fd = 2;   /* Error Handler */
 
	led_off(dev, LED_C608);
	led_off(dev, LED_C609);
 
success:
	return 0;
}
 
static struct hw_module_methods_t led_module_methods = {
    open: led_device_open
};
 
const struct led_module_t HAL_MODULE_INFO_SYM = {
    common: {
        tag: HARDWARE_MODULE_TAG,
        version_major: 1,
        version_minor: 0,
        id: LED_HARDWARE_MODULE_ID,
        name: "Sample LED Stub",
        author: "The Mokoid Open Source Project",
        methods: &led_module_methods,
    }
 
    /* supporting APIs go here. */
};

/*
 * Copyright (C) 2009 Mokoid Open Source Project
 * Copyright (C) 2009 Moko365 Inc
 * 
 * Author: Jollen Chen <jollen@jollen.org>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#include <hardware/hardware.h>
 
#include <fcntl.h>
#include <errno.h>
 
#include <cutils/log.h>
#include <cutils/atomic.h>
 
/***************************************************************************/
 
struct led_module_t {
   struct hw_module_t common;
};
 
struct led_control_device_t {
   struct hw_device_t common;
 
   /* attributes */
   int fd;
 
   /* supporting control APIs go here */
   int (*set_on)(struct led_control_device_t *dev, int32_t led);
   int (*set_off)(struct led_control_device_t *dev, int32_t led);
};
 
/***************************************************************************/
 
struct led_control_context_t {
	struct led_control_device_t device;
};
 
#define LED_HARDWARE_MODULE_ID "led"

• led.c
• led.h

on <trigger>
   <command>
   <command>
   <command>

setprop <name> <value>

setprop ro.product.device dma6410xp

<?xml version="1.0" encoding="utf-8"?>
<permissions>
    <library name="com.mokoid.server"
            file="/system/framework/mokoid.jar"/>
</permissions>

• 2010.2.8: MOSP: Mokoid Project (Mokoid Open Source Project) 上線

    @Override
    public Object getSystemService(String name) {
        if (getBaseContext() == null) {
            throw new IllegalStateException(
                    "System services not available to Activities before onCreate()");
        }
　
        if (WINDOW_SERVICE.equals(name)) {
            return mWindowManager;
        } else if (SEARCH_SERVICE.equals(name)) {
            ensureSearchManager();
            return mSearchManager;
        }
        return super.getSystemService(name);
    }

public class mokoidActivity extends Activity {
    ...
    @Override
    public Object getSystemService(String name) {
　
        if (MOTOR_SERVICE.equals(name)) {
            MotorManager mMotorManager = new MotorManager();
            return mMotorManager;
        }
        return super.getSystemService(name);
    }	
	...
}

public class HelloWorld extends mokoidActivity {
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.mokoid.LedTest"
    android:sharedUserId="android.uid.system">

int svc_can_register(unsigned uid, uint16_t *name)
{
    unsigned n;
    　
    if ((uid == 0) || (uid == AID_SYSTEM))
        return 1;
　
    for (n = 0; n < sizeof(allowed) / sizeof(allowed[0]); n++)
        if ((uid == allowed[n].uid) && str16eq(name, allowed[n].name))
            return 1;
　
    return 0;
}
　
int do_add_service(struct binder_state *bs,
                   uint16_t *s, unsigned len,
                   void *ptr, unsigned uid)
{
    struct svcinfo *si;
//    LOGI("add_service('%s',%p) uid=%d\n", str8(s), ptr, uid);
　
    if (!ptr || (len == 0) || (len > 127))
        return -1;
　
    if (!svc_can_register(uid, s)) {
        LOGE("add_service('%s',%p) uid=%d - PERMISSION DENIED\n",
             str8(s), ptr, uid);
        return -1;
    }
    ...
}

• SystemServer & ServerThread
• Main Thread
• android.app.Activity 與 android.app.Service
• Android Process 模式
• ServiceManager 與 getSystemService API
• JNI & Native Method
• Blocking & Long Operations
• VMThread & Thread
• Zygote 與 Linux fork System Call

• Manager API
• Proxy Object
• Remote Object
• Remotable Object
• IInterface & IServiceManager

static struct hw_module_methods_t led_module_methods = {
    open: led_device_open
};
　
const struct led_module_t HAL_MODULE_INFO_SYM = {
    common: {
        tag: HARDWARE_MODULE_TAG,
        version_major: 1,
        version_minor: 0,
        id: LED_HARDWARE_MODULE_ID,
        name: "Simple LED module",
        author: "The Mokoid Open Source Project",
        methods: &led_module_methods,
    }
　
    /* supporting APIs go here */
};

• tag：須指定為 HARDWARE_MODULE_TAG
• id：指定為 HAL Stub 的 module ID，我們的範例為”LED”
• methods：struct hw_module_methods_t，為 HAL 所定義的「method」
• struct hw_module_methods_t 是由 HAL 定義的標準介面，目前的 AOSP（Android Open Source Project）實作裡包含一個”open”介面

#include <hardware/hardware.h>

#define LED_HARDWARE_MODULE_ID "led"

struct led_module_t {
   struct hw_module_t common;
};

struct led_module_t {
   struct hw_module_t common;
   　
   /* Place attributes here. */
　
   /* Place methods here. */
};

• 採用Service架構方式
• 不採用Service架構方式

<?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"
    >
<Button
    android:layout_width="wrap_content" 
    android:layout_height="wrap_content" 
    android:text="small world"
    android:textSize="12sp"
    android:background="@drawable/arrow"
    />
<Button
    android:layout_width="wrap_content" 
    android:layout_height="wrap_content" 
    android:text="big world"
    android:textSize="24sp"
    android:background="@drawable/arrow"
    />
<Button
    android:layout_width="wrap_content" 
    android:layout_height="wrap_content" 
    android:text="super world"
    android:textSize="48sp"
    android:background="@drawable/arrow"
    />
</LinearLayout>

• 文字部份使用TextView元件
• 使用TextView的XML attribute來設定文字大小
• 使用TextView的XML attribute來設定一張背景圖
• 使用NinePatch圖片做為背景圖，如此一來背景圖就可以隨著文字大小縮放

package com.moko.hellointentwallaper;
　
import com.moko.hellointentwallaper.R;
　
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
　
public class HelloIntentWallpaper extends Activity implements View.OnClickListener {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        　
        Button button = (Button)findViewById(R.id.set_wallpaper);
        button.setOnClickListener(this);
    }
　
    public void onClick(View v) {
        Intent intent = new Intent(Intent.ACTION_SET_WALLPAPER);
        startActivity(Intent.createChooser(intent, "Select Wallpaper"));
    }
}

<?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"
	    />
    <Button android:id="@+id/set_wallpaper"
        android:layout_width="wrap_content" android:layout_height="wrap_content" 
        android:text="@string/set_wallpaper">
        <requestFocus />
    </Button>
</LinearLayout>

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.moko.hellointentdialer"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".HelloIntentDialer"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
    <uses-sdk android:minSdkVersion="3" />
    <uses-permission android:name="android.permission.CALL_PHONE" />
</manifest>>

• drawable-land/ - landscope 模式的圖檔
• drawable-port/ - portrait 模式的圖檔

338 KB/s (837376 bytes in 2.417s)
        pkg: /data/local/tmp/Launcher.apk
Success

• onUpdate(): 收到ACTION_APPWIDGET_UPDATE廣撥時，框架會callback此method
• onDelete(): 收到ACTION_APPWIDGET_DELETE廣撥時，框架會callback此method
• AppWidgetManager: 管理App Widget的類別

    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        final int N = appWidgetIds.length;
        for (int i=0; i<N; i++) {
            int appWidgetId = appWidgetIds[i];
            updateAppWidget(context, appWidgetManager, appWidgetId);
        }
    }

    static void updateAppWidget(Context context, AppWidgetManager appWidgetManager, int appWidgetId) {
    	CharSequence text;
    	      
    	text = "www.jollen.org";
    	        
        RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.main);
        views.setTextViewText(R.id.appwidget_text, text);
        
        appWidgetManager.updateAppWidget(appWidgetId, views);
    }
}

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.moko.hellowidget"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <receiver android:name=".HelloAppWidgetProvider">
            <meta-data android:name="android.appwidget.provider"
                    android:resource="@xml/appwidget_provider" />
            <intent-filter>
                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
            </intent-filter>
        </receiver>
    </application>
    <uses-sdk android:minSdkVersion="3" />
</manifest>

• onUpdate()
• onDelete()

<?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="wrap_content" 
    android:layout_height="wrap_content" 
    android:id="@+id/appwidget_text"
    android:textColor="#ff000000"
    />
</LinearLayout>

• 長度(width)
• 高度(height)
• 更新頻率
• UI layout檔

<?xml version="1.0" encoding="utf-8"?>
   
<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
    android:minWidth="85dp"
    android:minHeight="30dp"
    android:updatePeriodMillis="3000"
    android:initialLayout="@layout/main"
    >
</appwidget-provider>

/* 範例：HelloAppWidget.java */
package com.moko.hellowidget;
  
import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProvider;
import android.content.Context;
import android.widget.RemoteViews;
  
public class HelloAppWidgetProvider extends AppWidgetProvider {
  
    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        final int N = appWidgetIds.length;
        for (int i=0; i<N; i++) {
            int appWidgetId = appWidgetIds[i];
            updateAppWidget(context, appWidgetManager, appWidgetId);
        }
    }
      
    public void onDeleted(Context context, int[] appWidgetIds) {
    }
  
    static void updateAppWidget(Context context, AppWidgetManager appWidgetManager,
            int appWidgetId) {
    	CharSequence text;
      	
    	text = "www.jollen.org";
      	
        RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.main);
        views.setTextViewText(R.id.appwidget_text, text);
  
        appWidgetManager.updateAppWidget(appWidgetId, views);
    }
}

• res/xml/appwidget_provider.xml
• res/layout/main.xml
• src//HelloAppWidgetProvider.java
• AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <style name="myTheme">
    	<item name="android:windowNoTitle">true        
    </style> 
</resources>

標籤裡加上「theme」屬性：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.moko.hellotheme"
      android:versionCode="1"
      android:versionName="1.0.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name"
    	android:theme="@style/myTheme">
        <activity android:name=".HelloTheme"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

執行結果： 圖1: HelloTheme的執行結果 在這個範例裡，我們並沒有修改任何的程式碼，其原理是透過佈景設定的方法。定義佈景的方式與定義樣式（styles）相同，同樣是在styles.xml裡以<item>標籤來定義。 以下是使用HelloTheme的說明： 1. <item>的name屬性為android:windowNoTitle時，表示定義是否要顯示視窗標題，在此設定為true，表示不要有視窗標題 2. 在<application>標籤裡加上theme屬性，將佈景套用到應用程式 佈景除了能套用到應用程式外，也能套用到activity。如何套用佈景到activity呢？只要在<activity>裡加入theme屬性即可，做法與<application>相同。]]>

• 在Android專案裡以XML資源檔來定義「樣式」
• 一個Android專案可以定義多個樣式
• 讓widget套用其中一個樣式

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <style name="myText">
        <item name="android:textSize">18sp</item>
        <item name="android:textColor">#880</item>
    </style>
</resources>

<?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="Hello, this is HelloStyles."
    style="@style/myText"
    />
 </LinearLayout>

import android.view.View;
  
public class HelloClickListener extends Activity implements View.OnClickListener {
   ...
}

   public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        Button button = (Button)findViewById(R.id.btn);
        button.setOnClickListener(this);
    }

   public void onClick(View v) {
        Toast.makeText(
                this,
                "Yes.",
                Toast.LENGTH_LONG).show();  
    }

package com.moko.helloclicklistener;
   
import android.app.Activity;
import android.os.Bundle;
import android.widget.Button;
import android.widget.Toast;
import android.view.View;
   
public class HelloClickListener extends Activity implements View.OnClickListener {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        Button button = (Button)findViewById(R.id.btn);
        button.setOnClickListener(this);
    }
    
    public void onClick(View v) {
        Toast.makeText(
                this,
                "Yes.",
                Toast.LENGTH_LONG).show();  
    }
}

• View.OnLongClickListener: onLongClick()
• View.OnFocusChangeListener: onFocusChange()
• View.OnKeyListener: onKey()
• View.OnTouchListener: onTouch()
• View.OnCreateContextMenuListener: onCreateContextMenu()

14 /*
15
16 Goals and Theory of Operation
17
18 The primary goal of this feature is to reduce the kernel boot time,
19 by doing various independent hardware delays and discovery operations
20 decoupled and not strictly serialized.
21
22 More specifically, the asynchronous function call concept allows
23 certain operations (primarily during system boot) to happen
24 asynchronously, out of order, while these operations still
25 have their externally visible parts happen sequentially and in-order.
26 (not unlike how out-of-order CPUs retire their instructions in order)
27
28 Key to the asynchronous function call implementation is the concept of
29 a "sequence cookie" (which, although it has an abstracted type, can be
30 thought of as a monotonically incrementing number).
31
32 The async core will assign each scheduled event such a sequence cookie and
33 pass this to the called functions.
34
35 The asynchronously called function should before doing a globally visible
36 operation, such as registering device numbers, call the
37 async_synchronize_cookie() function and pass in its own cookie. The
38 async_synchronize_cookie() function will make sure that all asynchronous
39 operations that were scheduled prior to the operation corresponding with the
40 cookie have completed.
41
42 Subsystem/driver initialization code that scheduled asynchronous probe
43 functions, but which shares global resources with other drivers/subsystems
44 that do not use the asynchronous call feature, need to do a full
45 synchronization with the async_synchronize_full() function, before returning
46 from their init function. This is to maintain strict ordering between the
47 asynchronous and synchronous parts of the kernel.
48
49 */

public boolean onOptionsItemSelected(MenuItem item) {
    	int item_id = item.getItemId();
    	
    	switch (item_id){
    		case R.id.new_message: 
	    	        AlertDialog.Builder builder = new AlertDialog.Builder(this);
	    	        
	    	        builder.setMessage("Also post your message to Twitter?");
	    	        builder.setCancelable(false);
	    	        
	    	        builder.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
	    	        	public void onClick(DialogInterface dialog, int id) {
	    	        	}
	    	        });
	    	        
	    	        builder.setNegativeButton("No", new DialogInterface.OnClickListener() {
	    	        	public void onClick(DialogInterface dialog, int id) {
	    	        	}
	    	        });   
	    	        
	    	        AlertDialog alert = builder.create();
	    	        alert.show();
    			break;
    		case R.id.quit: 
                Toast.makeText(
                        this,
                        "Going to quit.",
                        Toast.LENGTH_LONG).show();    			
    			break;
    		default: return false;
    	}
    	return true;
 }

builder.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
	public void onClick(DialogInterface dialog, int id) {
		}
});

import android.widget.Toast;

這是一個很好用的類別，特別是在初步建立Android應用程式的控制或行為時，可以輔助我們進行初步的測試工作。

配合上述的選單範例，我們將onOptionsItemSelected()回呼函數實作修改如下：

    public boolean onOptionsItemSelected(MenuItem item) {
    	int item_id = item.getItemId();
    	
    	switch (item_id){
    		case R.id.new_message: 
                Toast.makeText(
                        this,
                        "Please enter your message."
                                + " Your message is at max 255 characters.",
                        Toast.LENGTH_LONG).show();
    			break;
    		case R.id.quit: 
                Toast.makeText(
                        this,
                        "Going to quit.",
                        Toast.LENGTH_LONG).show();    			
    			break;
    		default: return false;
    	}

此範例以Toast快顯訊息類別來顯示簡短訊息，以驗證上一個選單範例的功能是否正常。

1. 建立選單的XML檔

在Android專案的res/目錄下新增一個menu/子目錄，然後建立options_menu.xml文件。

圖1: 建立menu/目錄

圖2: 建立options_menu.xml文件

2. 以XML定義選單內容

在options_menu.xml檔案裡，定義我們想要的選單內容。以下是一個範例：

<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/new_message"
          android:title="New Message" />
    <item android:id="@+id/quit"
          android:title="Quit" />
</menu>

3. 將選單加入應用程式

要如何在應用程式啟動時加入我們定義好的選單呢？在onCreateOptionsMenu()事件裡以MenuInflater類別將定義好的選單加入應用程式：

public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.options_menu, menu);
    return true;
}

在這個範例裡，我們使用到二個類別：Menu與MenuInflater，因此記得import這二個套件：

import android.view.Menu;
import android.view.MenuInflater;

按下手機上的Menu鍵後，出現我們所設計的選單，如圖3。

圖3: HelloMenu範例的選單畫面

最後一個問題是，當使用者觸壓選單上的選項時，Android應用程式要如何處理？方法是透過onOptionsItemSelected()事件：

    public boolean onOptionsItemSelected(MenuItem item) {
    	return true;
    }

當此事件被回呼時，Android框架傳入被觸壓的選項物件，其類別為MenuItem；請import此套件：

import android.view.MenuItem;

前述的教學提到，Android應用程式編譯時，會自動產生R類別，即描述UI的類別。我們所定義的選單UI也會被放到R類別裡，如下：

package com.moko.hellomenu;

public final class R {
    public static final class attr {
    }
    public static final class drawable {
        public static final int icon=0x7f020000;
    }
    public static final class id {
        public static final int new_message=0x7f060000;
        public static final int quit=0x7f060001;
    }
    public static final class layout {
        public static final int main=0x7f030000;
    }
    public static final class menu {
        public static final int options_menu=0x7f050000;
    }
    public static final class string {
        public static final int app_name=0x7f040001;
        public static final int hello=0x7f040000;
    }
}

以下是處理MenuItem的程式範例：

    public boolean onOptionsItemSelected(MenuItem item) {
    	int item_id = item.getItemId();
    	
    	switch (item_id){
    		case R.id.new_message: break;
    		case R.id.quit: break;
    		default: return false;
    	}
    	return true;
    }

呼叫MenuItem的getItemId()方法，可取得該選項的ID，如此一來便能得知使用者所觸壓的選項。

/* 範例檔名：HelloMenu.java */
package com.moko.hellomenu;

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;

public class HelloMenu extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
    
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.options_menu, menu);
        return true;
    }
    
    public boolean onOptionsItemSelected(MenuItem item) {
    	int item_id = item.getItemId();
    	
    	switch (item_id){
    		case R.id.new_message: break;
    		case R.id.quit: break;
    		default: return false;
    	}
    	return true;
    }
}

1. 簡報一份
2. Android 入門教學文件共11集
3. 範例程式4例

因為研討會是一天的演講活動，因此這些內容很適合新手做為「學習 Android 應用程式」的入門教材，大約只需要一天的時間，就能初步了解 Android 的開發工具使用，並了解 Android 的應用程式模式，故取名為「Android Day Package」，期望能提供一個「Android 新手一天入門」的教學套件。請不吝指教。

簡報的部份是受零組件雜誌邀請，進行一天的 Android 演講活動，所特別製作的簡報；範例則是參考 Android SDK 所撰寫的實例，範例是配搭簡報進行實例講解所使用的程式碼。[下載 Android Day Package] 後，可搭配以下共11份教學文件學習；以下的教學文件是為製作簡報時的筆記，特別整理成一份教學文件與大家分享。

課程主題

Android 教學

• 2009.01.19: Jollen 的 Android 教學,#11: AndroidManifest.xml 的用途是什麼？
• 2009.01.19: Jollen 的 Android 教學,#10: 如何檢查 Service 是否已啟動？使用 Android 除錯器
• 2009.01.12: Jollen 的 Android 教學,#9: 啟動 Service - startService()
• 2009.01.12: Jollen 的 Android 教學,#8: 沒有 UI 的 Service
• 2009.01.08: Jollen 的 Android 教學,#7: 如何讓文字並排顯示 - TableLayout
• 2009.01.05: Jollen 的 Android 教學,#6: WebView 體驗與 findViewByID
• 2009.01.04: Jollen 的 Android 教學,#5: 使用 View 的 XML 屬性
• 2009.01.04: Jollen 的 Android 教學,#4: 使用 XML 安排 UI
• 2008.12.29: Jollen 的 Android 教學,#3: 第一個 Android 專案
• 2008.12.29: Jollen 的 Android 教學,#2: “Hello Moko” - Activity 與 View 的關係
• 2008.12.29: Jollen 的Android 教學,#1: Android 應用程式模式

    <application android:icon="@drawable/icon" android:label="@string/app_name">
    ...
        <service android:name=".MokoService">
        ...
        </service>
    ...
    </application>

       <service android:name=".MokoService">
        	<intent-filter>
        		<action android:name="com.moko.hello.START_MUSIC" />
        		<category android:name="android.intent.category.DEFAULT" />
        	</intent-filter>
        </service>

	@Override
	public void onStart(Intent intent, int startId) {
		super.onStart(intent, startId);
	}

在 Package Explorer 視窗裡找到目前 Android 專案的資訊描述檔，檔名是 AndroidManifest.xml。這是一個用來描述 Android 應用程式「整體資訊」的檔案，每個 Android 應用程式專案都會有一個。在這裡修改 Androidmanifest.xml 的目的是為了「在我們的 Android 應用程式裡加入一個 Service 類別」，這樣才有辦法啟動 Service。修改後的內容如下，紅色的部份是新增的描述：。

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.moko.hello"
      android:versionCode="1"
      android:versionName="1.0.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name" android:debuggable="true">
        <activity android:name=".HelloMoko"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service android:name=".MokoService">
            <intent-filter>
                <action android:name="com.moko.hello.START_MUSIC" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </service>
    </application>
</manifest>

這是什麼意思呢？我們留待後續再做說明。接著只需要再加上一行程式碼，就能啟動 MokoService 類別了。

回到 HelloM 類別，加入一行程式碼：

public class HelloMoko extends Activity {
   /** Called when the activity is first created. */
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState); 
       
       setContentView(R.layout.main);
       
       startService(new Intent ("com.moko.hello.START_MUSIC"));
   }
}

Activity 類別裡有一個 method 叫做 startService：

startService(Intent service)

呼叫 startService() 即可啟動一個 Service 類別，只是，startService() 的參數是一個「Intent」的型別，並不是所要啟動的類別名稱。「Intent」是一個很像「Event」的類別，後續我們再做比較精確的說明，在這裡，我們不如把 Intent 當成是 Event（事件）。

當程式送出 com.moko.hello.START_MUSIC 事件給 Android 時，Android 便去尋找能處理此事件的類別，然後啟動它。在這裡，能處理 com.moko.hello.START_MUSIC 事件的類別就是 MokoService，這個關係就是透過 AndroidManifest.xml 的設定實現的。

以下是利用 Eclipse 環境自動產生的類別 'MokoService'：

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;

public class MokoService extends Service {

	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		return null;
	}

}

MokoService 類別繼承自 android.app.Service，幾個有關 Service 的重要觀念如下：

1. Service 物件以 separated process 的方式執行，這表示 Service 與 UI（Activity）並不在同一個 process 裡執行，而是個自在不同的 process 執行。

2. Android 應用程式是在 Activity 裡啟動與停止 Service。

3. 覆載（override）onStart() 方法（method）在 Service 被啟動時，執行我們想要的背景功能。

4. 覆載 onDestroy() 方法在 Service 被停止時，停止執行中的背景功能。

以下是一個加入 onStart 與 onDestroy 的 MokoService 實作：

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;

public class MokoService extends Service {

	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		return null;
	}
	
	@Override
	public void onStart(Intent intent, int startId) {
		
	}
	
	@Override
	public void onDestroy() {
		
	}
}

圖1: 文字並排顯示

建立新的專案「HelloLayout」，並撰寫程式碼如下：

package com.moko.layout;

import com.moko.layout.R;

import android.app.Activity;
import android.os.Bundle;

public class HelloLayout extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

由於我們採用 XML layout 的做法，所以主程式不需要做什麼修改。本範例的重點應該是在 main.xml 檔案的編寫。

新的 Android 專案創建時，預設是使用 LinearLayout（線性排版）來安排 UI。現在，我們將使用 TableLayout 來取代 LinearLayout，以「表格」方式來安排 UI。TableLayout 讓我們可以將畫面切割成一張表格，如果我們可以設計一個二欄式（2 columns）的表格，就可以做出如圖1的顯示效果了。

以下是 main.xml 的內容：

<?xml version="1.0" encoding="utf-8"?>

<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">

	<TableRow>
		<TextView  
		    android:layout_width="fill_parent" 
		    android:layout_height="wrap_content" 
		    android:text="www.androidin.com"
		    android:padding="3dip"
		    android:autoLink="web" />
		<TextView  
		    android:layout_width="fill_parent" 
		    android:layout_height="wrap_content" 
		    android:text="www.google.com"
		    android:autoLink="web" />
	</TableRow>

</TableLayout>

android.widget.TableRow 是配合 TableRow 使用的一個類別，當我們在 TableLayout 裡安排一個 TableRow 時，在 TableRow「裡頭的所有 View」就會被安排在同一列（row）裡。以本範例來說，在第一列（row）裡有二個 TextView，所以這二行文字顯示時，就會呈現如圖1的效果。

為了避免文字擠在一起，因此我們在 TextView 裡加上了 padding 的屬性，如下：

第一個 TextView 的 padding 為 3dip，表示與旁邊的 View 必須空 3 個「間格」，這樣二個 TextView 才不會擠在一起。

接下來請依照以下步驟，建立我們的第二個 Android 應用程式「Hello Web」。

建立一個新的 Android 專案，如圖1。

並且撰寫 HelloWeb.java 程式如下：

package com.moko.web;

import android.app.Activity;
import android.os.Bundle;
import android.webkit.WebView;

import com.moko.web.R;

public class HelloWeb extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        final String mimetype = "text/html";
        final String encoding = "utf-8";
        
        WebView wv;
        
        wv = (WebView) findViewById(R.id.wv);
        wv.loadData("<img src=\"http://www.google.com.tw/intl/en_com/images/logo_plain.png\" />", mimetype, encoding);
    }
}

上述程式碼採用 XML layout 方式來安排 UI，因此接下來的工作就是編輯 XML layout 檔案。

編輯 main.xml 來規劃「Hello Web」的 UI 如下：

<?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="wrap_content"
    >
<WebView 
	android:layout_width="fill_parent" 
	android:layout_height="wrap_content" 
	android:id="@+id/wv" 
	/>
</LinearLayout>

在這裡我們定義了「WebView」標籤，並且指定「WebView」的 ID 為「wv」。透過指定「ID」屬性給 View 的方式，便能「讓 Android 應用程式在執行時期（run-time）找到指定的 View 物件」。

怎麼在執行時期，找到「XML layout」安排好的 View 呢？看到 HelloWeb.java 的程式片斷如下：

        final String mimetype = "text/html";
        final String encoding = "utf-8";
        
        WebView wv;
        
        wv = (WebView) findViewById(R.id.wv);
        wv.loadData("<img src=\"http://www.google.com.tw/intl/en_com/images/logo_plain.png\" />", mimetype, encoding);

呼叫 findViewByID() 方法，即可在執行時期「動態取得 View 物件」。當我們在 main.xml 裡加入 WebView 標籤，「存檔」後，R.java 資源索引檔也會跟著更新，我們可透過「R.id.wv」來索引到 WebView 物件。以下是 R.java 的內容：

package com.moko.web;

public final class R {
    public static final class attr {
    }
    public static final class drawable {
        public static final int icon=0x7f020000;
    }
    public static final class id {
        public static final int wv=0x7f050000;
    }
    public static final class layout {
        public static final int main=0x7f030000;
    }
    public static final class string {
        public static final int app_name=0x7f040001;
        public static final int hello=0x7f040000;
    }
}

取得 WebView 物件後，呼叫 WebView 的 loadData() 方法，將 HTML 內容載入到 WebView 物件裡，並顯示在 Activity 上。loadData() 的參數如下：

• 第一個參數：HTML 內容
• 第二個參數：MimeType 類型，指定為 text/html，即 HTML 類型文件
• 第三個參數：文字編碼方法，指定為 utf-8（Unicode）

Hello Web 範例程式所載入的 HTML 文件是一個 <IMG> 標籤，因此我們在視窗上所看到的內容就是一張圖檔，如下圖（使用真正的 Google Phone 做測試）。

<?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="Jollen's Blog - http://www.jollen.org/blog"
    android:autoLink="web"
    />
</LinearLayout>

Android 應用程式的 layout（UI 佈局）除了直接撰寫程式碼的方式外，也能使用 XML 檔案來做描述（XML-based Layout）。在 Android Development Kit 的「Package Explorer」視窗，點選「res -> layout」選擇 main.xml，可以看到 “Hello Moko” 應用程式的 XML layout 檔案，如圖1。

以下這段 XML 用來描述「TextView」物件的 layout：

<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/hello"
    />

public class HelloMoko extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        setContentView(R.layout.main);
	}
}

當 Activity 被建立後，我們呼叫 setContentView() 方法，將主要的 UI（R.layout.main）顯示在視窗上。R.layout.main 索引到一個 TextView 物件，此物件定義於 main.xml。將 R.layout.main 顯示在 Activity 視窗上，請記得修改程式碼，才能使用 XML-based layout。

我們順帶將 TextView 物件的 text 屬性修改如下：

<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="Hello TextView"
    />

[2008-12-29 16:51:29 - HelloMoko] ------------------------------
[2008-12-29 16:51:29 - HelloMoko] Android Launch!
[2008-12-29 16:51:29 - HelloMoko] adb is running normally.
[2008-12-29 16:51:29 - HelloMoko] Launching: com.moko.hello.HelloMoko
[2008-12-29 16:51:32 - HelloMoko] Uploading HelloMoko.apk onto device 'HT843GZ46367'
[2008-12-29 16:51:32 - HelloMoko] Installing HelloMoko.apk...
[2008-12-29 16:51:35 - HelloMoko] Success!
[2008-12-29 16:51:35 - HelloMoko] Starting activity com.moko.hello.HelloMoko on device 
[2008-12-29 16:51:36 - HelloMoko] ActivityManager: Starting: Intent { comp={com.moko.hello/com.moko.hello.HelloMoko} }

package com.moko.hello;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class HelloMoko extends Activity {
   /** Called when the activity is first created. */
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);

       TextView tv = new TextView(this);
       tv.setText("Hello Moko");
       setContentView(tv);
   }
}

這是在 Android SDK 文件裡的一段範例程式，類別 HelloAndroid 繼自 Activity。下圖是Activity的生命週期（lifecycle）。在「Jollen 的 Android 教學,#1」裡提到 Activity 負責建立視窗，根據 Activity lifecycle，當視窗建立時，onCreate 事件被觸發，所以我們在 onCreate 裡建立 View。

TextView 是 Android 的其中一個 View，故名思義，這是一個顯示文字的 View。最後，呼叫 Activity 的 method 'setContentView' 來將 UI 顯示於視窗上。

以下是一段正常的 open system call 實作：

int card_open(struct inode *inode, struct file *filp)
{
	return 0;
}

當 process 開啟 device file 後，因為 kernel-space 的 open system call 實作會直接 return，因此 CPU 會切換至前景（foreground）、 process 繼續往下執行。

第二段是不正確的 open system call 實作：

int card_open(struct inode *inode, struct file *filp)
{
	while (1);
	return 0;
}

當 process 開啟 device file 後，因為 CPU 切換至後景（background），但是在 OS 裡頭的 open system call 實作是一個無窮迴圈，OS 並沒有做 system call 的返回，因此 CPU 並不會切換到前景，所以，電腦感覺起來呈現「當機」狀態。

因為 CPU 的時間無法切換到前景，因此任何的 process 都無法執行，電腦當然沒有任何反應。這裡，可沒有所謂的「time slice」與「context switch」的觀念與動作。請同學思考：作業系統是對 process 做排程。

最後一段程式，我們加入了呼叫排程器的動作：

int card_open(struct inode *inode, struct file *filp)
{
	while (1)
		schedule();
	return 0;
}

schedule() 是排程器主函數，等於是主動呼叫 scheduler 做 re-scheduling。在這個情況下，雖然 OS 仍然沒有做 system call 返回，但因為我們以「手排」的方式做排程，因此 CPU 會換切到前景，前景程式就會被分配時間執行，因此，電腦仍然有反應。

唯一要注意的地方是，因為這一個 open system call 並沒有 return，所以原來的 process 並不會繼續往下執行。利用三段簡單的程式碼，對作業系統的排程觀念做了一次討論，對於建立「什麼是 scheduling」的觀念，是很有幫助的。

$ lsusb
Bus 007 Device 002: ID 04b4:1724 Cypress Semiconductor Corp. 
Bus 007 Device 001: ID 0000:0000  
Bus 003 Device 001: ID 0000:0000  
Bus 006 Device 001: ID 0000:0000  
Bus 005 Device 034: ID 1457:5117 
Bus 005 Device 001: ID 0000:0000  
Bus 004 Device 001: ID 0000:0000  
Bus 004 Device 004: ID 04d9:0499 Holtek Semiconductor, Inc. 
Bus 002 Device 001: ID 0000:0000  
Bus 001 Device 001: ID 0000:0000

$ ps ax|grep adb
20092 ?        S+     0:00 grep adb
21032 ?        Sl     0:00 adb fork-server server
$ sudo kill -9 21032

$ sudo ifconfig usb0 192.168.0.200

$ export ADBHOST=192.168.0.202

$ adb devices
* daemon not running. starting it now *
* daemon started successfully *
List of devices attached 
emulator-5554   device

$ adb install HelloMoko.apk

Neo FreeRunner 有二個 3 軸加速度感測器，當手機移動時，可以利用程式讀取每 一個軸的加速度值。讀取加速度感測器的方法是透過 Linux 的 input layer：

    /dev/input/event{2,3}

Process 透過這二個裝置檔讀取 input layer 的資料，kernel 會回傳一筆加速度感測器的資料給 process，該筆資料的 data type 為 struct input_event，即 kernel 的 input event 資料結構。程式的做法是，每次讀取一筆加速度感測器資料，再判斷資料的類型，以及各軸的加速度值。

程式寫法如下：

    #include <linux/input.h>

    int main(void)
    {

        struct input_event motion;

        fd = open("/dev/input/event3", S_IRUSR);

        while (1) {
            read(fd, &motion, sizeof(motion));
        }
    }

struct input_event 資料結構的定義如下：

    struct input_event {
        struct timeval time;
        __u16 type;
        __u16 code;
        __s32 value;
    };

讀出的資料如下：

• motion.time: 讀取到該筆資料的時間
• motion.type: 值為 2 時，表示該筆資料為加速度值
• motion.code: 表示讀取的加速度方向，0 = x 軸、1 = y 軸、2 = z 軸
• motion.value: 該軸的加速度值，正負號代表「正負方向」

本範例讀取 FreeRunner 上的第二個 3 軸加速度感測器，x/y/z 軸所代表的方向如下圖。

如果想要讀取 x 軸的加速度：

    int x;

    /* 資料有效且為 x 軸 */
    if (motion.type == 2 && motion.code == 0) {
        x = motion.value;
    }

若 x 為負值，表示手機往左邊的方向移動。再舉一個例子，讀取 y 軸的加速度：

    int y;

    /* 資料有效且為 y 軸 */
    if (motion.type == 2 && motion.code == 1) {
        y = motion.value;
    }

若 y 軸的加速度為正值，表示手機往下移動。更多有關 FreeRunner 加速度感測器（accelerometer）的資訊，可參閱 Openmoko wiki [Accelerometer data retrieval]。

「專利權本身的目的是為鼓勵人們將新創概念公佈出來，但現行的專利體系卻會造成反效果，」

現今能做UI的技術很多，其中相對比較容易的方式就是以script language來打造UI，而當前最受注意的方式就是以Python快速寫UI。當然，網路上還有許多不同的UI技術，像是能讓「designer」真正自由發揮、免除寫code的SVG browser，也是一個值得注意的技術。

今天要介紹的主角是python-etk，故名思義，這是Python的ETK模組。ETK是一個不錯的東西，全名是Enlightenment Tool Kit，它的功能定位就像是GTK+的角色。GTK+是大名鼎鼎的圖形元件（widget）庫，由GTK+專案所沿伸出來的Glib也是一個使用廣泛的「強化版C程式庫」。ETK有沒有像Glib這樣的東西？有的，叫做Ecore。

Enlightenment（簡稱E）是一個知名且古老的window manager。[Enlightenment]包含許多程式庫以及工具，這些程式庫與工具總稱為EFL（Enlightenment Foundation Libraries）。簡單來看，可以畫出EFL的架構如下。

EVAS是一個「畫布」程式庫。Ecore的角色如同GTK+的產物Glib，不過並不完全等於。EDJE則是一個「layout engine」。最上面的ETK就是我們的主角，Enlightenment的圖形元件庫。

透過python-etk來實作ETK應用程式，可以帶給我們一些愉快的經驗。要怎麼寫一個向世界問好的入門級python-etk程式呢？以下是一個範例（hello_world.py）：

#!/usr/bin/python

import etk

class MyButton(etk.Button):
	def _size_request(self):
	    return (100, 200)

btn = MyButton(label = "Click Me")
btn.on_clicked(lambda x: etk.main_quit())

# Main
w = etk.Window(title="Hello World", size_request=(150, 150), child=btn)
w.show_all()

def quit(obj):
    etk.main_quit()
w.on_destroyed(quit)

etk.main()

目前有一些知名的Linux手機專案已經開始使用python-etk，例如Openmoko以及Nokia的maemo專案。後續將再配合一個範例來說明hello_world.py程式，及其執行結果。

We are pleased to announce that OpenedHand Ltd has been acquired by Intel Corporation. The OpenedHand team will join the Intel Open Source Technology Center and will focus on the development of the Moblin Software Platform, the optimized software stack for Intel Atom processors. Intel will continue supporting open source projects currently led by OpenedHand staff such as Clutter and Matchbox projects, and in most cases, will accelerate these projects as they become an integral part of Moblin.

$ gcc -o n_fork n_fork.c
$ ./n_fork &
This is the child process. PID: 8450
This is the child process. PID: 8451
This is the child process. PID: 8452
Parent process, PID: 8449
Child process ID: 8450 8451 8452

$ gcc -o helo helo.c
$ ./helo
0x80495c0
now x = 10
now x = 100

But unfortunately, people probably wont buy it...

but let us still cheer the OpenMoko team on for making a brave step forward.

#define TASK_RUNNING 0
#define TASK_INTERRUPTIBLE 1
#define TASK_UNINTERRUPTIBLE 2

set_current_state(state_value)

Raising Operator Confidence in Open Source, Guido Arnone, Director,Terminals Technology Vodafone * What is the benefit of Open Source for Operators? * What reservations are there about Open Source? * Understanding what the Operator wants to hear * Are Operators comfortable outside the walled garden?

The core Android system will be open source, but there’s no guarantee that carrier,s OEMs and application developers will keep their applications open source.

TOOL_TOP = /opt/crosstool/gcc-3.4.1-glibc-2.3.3/arm-9tdmi-linux-gnu
CC = $(TOOL_TOP)/bin/arm-9tdmi-linux-gnu-gcc
AR = $(TOOL_TOP)/bin/arm-9tdmi-linux-gnu-ar
LD = $(TOOL_TOP)/bin/arm-9tdmi-linux-gnu-ld
AS = $(TOOL_TOP)/bin/arm-9tdmi-linux-gnu-as
STRIP = $(TOOL_TOP)/bin/arm-9tdmi-linux-gnu-strip
RANLIB = $(TOOL_TOP)/bin/arm-9tdmi-linux-gnu-ranlib
TARGET_ARCH = arm-linux

THTTPD_CFLAGS = -Os -Wall -mtune=arm9tdmi -march=armv4 \
                -fomit-frame-pointer -fsigned-char -fPIC

configured-thttpd:
        (export CC=$(CC); \
        export AR="$(AR)"; \
        export AS=$(AS); \
        export LD=$(LD); \
        export STRIP=$(STRIP); \
        export RANLIB=$(RANLIB); \
        export CFLAGS="$(THTTPD_CFLAGS)"; \
        ./configure \
                --prefix=/ \
                --host=$(TARGET_ARCH) );

thttpd: configured-thttpd
        make

$ make -f thttpd.cross thttpd

"I am amazed at the depth of your commitment to open design. This must be the first time in history that a company has opened its intellectual property to this extent. Openmoko's revolutionary posting of the CAD files gives a whole new generation of Industrial Design students incredible insight into how it's done as well as an opportunity to contribute with new concepts."

int request_irq( unsigned int   irq,
                 void           (*handler)(int, void *, struct pt_regs *),
                 unsigned long  irqflags,
                 const char    *devname,
                 void          *dev_id);

JASA乃是日本社團法人嵌入式系統技術協會(Japan Embedded Systems Technology Association )的英文簡稱 。JASA成立於1986年8月7日，總部設在東京都中央區，分布則有札幌、東京、名古屋、金沢、大阪、福岡。目前會員數包括正會員: 148家企業 以及贊助會員:35家企業。

JASA主要的事業內容

日本最大的嵌入式技術展示會 ET SHOW (Embedded Technology） 每年11月在橫濱Pacafico Yokohama 舉行的日本業界嵌入式最大的展示會是由JASA所主辦的。而ET2007 也在2007年11月14 - 16日舉行完畢。

西日本地區唯一的嵌入式技術展示會 ETWest 西日本地區首屆以及第二屆的嵌入式系統技術展示會均於2006年和2007年在大阪Mydome Osaka會場舉行。不論是參展廠商及觀展人數均大幅超出大會預期，也顯示了西日本地區對於嵌入式系統技術的高度關心與注目。今年(2008年)西日本嵌入式系統技術展示會將移到大阪Intex Osaka會場舉行。展出日期為2008/6/5(Thu) - 6/6(Fri)。

嵌入式技術工程師認證制度「ETEC」(Embedded Technology Engineer Certification) JASA亦同時提供嵌入式技術工程師認證制度「ETEC」。這個認證制度主要目的在於「提供高教育的品質與標準化的技術範圍指標，同時希能促進嵌入式系統在業界的活躍度」。認證分為兩個等級，Class 2 初階 與 Class 1 中階，參加認證考試者將可得到JASA發行的證書。

ET軟體設計機器人比賽 (ET Robo ) ET軟體設計機器人比賽是以嵌入式軟體領域的技術教育為主題，且以樂高積木為車體，在既定走道上自動競速的一種比賽。並使用同一硬體(車體)，來進行UML等分析以及軟體設計的比賽。除了在夏季舉行的競技賽之外，在ET會期期間也會在展示會場內舉辦冠軍大賽。

與海外的嵌入式相關團體・企業之結盟提攜 JASA為促進提升與海外嵌入式業界的合作關係，除了邀請泰國，印度等海外嵌入式系統團體，前往當地廠商視察之外，也積極推動海外交流，因此在2006年11月15日JASA也與台北市電腦協會(TCA)締結MOU協定。

嵌入式系統技術教育相關 JASA也以嵌入式技術者的 Skill Standard(ETSS)為評量基準，建立培育嵌入式系統技術者(工程師)的基礎架構，並逐步進行Skill認定的實證實驗等相關準備階段。同時並網羅業界相關人士組成工作小組(WG)進行相關研究。

嵌入式技術者教育養成 JASA提供嵌入式技術的專門技術教育以及新人入門教育。期能在企業內訓之外，發揮補強機能。

要撰寫一支 user-space 的 USB device 控制程式，最首要的工作就是找到自己的 USB 裝置。這個工作主要透過以下 4 個函數來進行：

• usb_init: 初始化 libusb
• usb_find_busses: 尋找系統裡的所有 USB bus
• usb_find_devices: 尋找所有的 USB bus 上的所有 USB device
• usb_get_busses: 傳回找到的 USB bus

程式一開始必須先呼叫 usb_init 將 libusb 做初始化，這是 libusb 程式第一個要呼叫的函數。接著依序呼叫 usb_find_busses 與 usb_find_devices 找到所有的 USB bus 與 USB device。

最後，呼叫 usb_get_busses 取得所有找到的 USB bus。程式如下：

    usb_init();
    usb_find_busses();
    usb_find_devices();

    struct usb_bus *busses;
    busses = usb_get_busses();

*busses 指向一個串列資料結構（struct usb_bus），訪問這個串列即可找到所有的 USB 裝置。

接下來，我們要在所有的 USB bus 上偵測系統是否有我們的 USB device。以下是這段程式的框架：

    struct usb_bus *bus;
    for (bus = busses; bus; bus = bus->next) {
	    struct usb_device *dev;

	    for (dev = bus->devices; dev; dev = dev->next) {
               struct usb_device_descriptor *desc;

               desc = &(dev->descriptor);
               printf("Vendor/Product ID: %04x:%04x\n", desc->idVendor, desc->idProduct);
	    }
    }

這段演算法可以將系統上所有 USB device 的 vendor id 與 product id 印出來。假如，我們想找到特定的 USB 裝置，這時就可以設計一個這樣的函數（假設我們想要找的 USB 裝置是 0xffff/0x0001）：

struct usb_device *usbio_probe()
{
    struct usb_bus *busses, *bus;
    int c, i, a;

    usb_init();
    usb_find_busses();
    usb_find_devices();

    busses = usb_get_busses();

    for (bus = busses; bus; bus = bus->next) {
	struct usb_device *dev;

	for (dev = bus->devices; dev; dev = dev->next) {
	    struct usb_device_descriptor *desc;

	    desc = &(dev->descriptor);
	    printf("Vendor/Product ID: %04x:%04x\n", desc->idVendor,
		   desc->idProduct);
	    if ((desc->idVendor == 0xffff) && (desc->idProduct == 0x0001)) {
		return dev;
	    }
	}
    }

    return NULL;
}

找到我們的 USB device 後，接著就可以對它進行操作（讀/寫）。如同操作檔案般，我們要先對 USB device 做開啟的動作，方式是呼叫 usb_open 函數：

usb_dev_handle *usb_open(struct *usb_device dev);

開啟成功後，會傳回此裝置的 handle。

以下提供學習 libusb 的第一個範例程式：

/*
 * findusb.c - A libusb sample program.
 *
 *  Authored by Jollen Chen 
 *
 *  Copyright (C) 2008 www.jollen.org
 *  Copyright (C) 2008 Jollen's Consulting, Inc.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU Public License as published by
 *  the Free Software Foundation; version 2 of the license.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser Public License for more details.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <usb.h>
#include <libusb.h>

void usbio_main(struct usb_device *dev)
{
    usb_dev_handle *dev_handle;

    dev_handle = usb_open(dev);

    if (dev_handle == NULL) {
	printf("USB IO open failed.\n");
	return;
    }

    usb_close(dev_handle);
}

struct usb_device *usbio_probe()
{
    struct usb_bus *busses, *bus;
    int c, i, a;

    usb_init();
    usb_find_busses();
    usb_find_devices();

    busses = usb_get_busses();

    for (bus = busses; bus; bus = bus->next) {
	struct usb_device *dev;

	for (dev = bus->devices; dev; dev = dev->next) {
	    struct usb_device_descriptor *desc;

	    desc = &(dev->descriptor);
	    printf("Vendor/Product ID: %04x:%04x\n", desc->idVendor,
		   desc->idProduct);
	    if ((desc->idVendor == 0xffff) && (desc->idProduct == 0x0001)) {
		return dev;
	    }
	}
    }

    return NULL;
}

int main()
{
    struct usb_device *dev;
    struct usb_device_descriptor *desc;

    dev = usbio_probe();
    desc = &(dev->descriptor);

    if (dev == NULL) {
	printf("USB IO Card not found.\n");
	return -1;
    }

    printf("SUB IO Card found.\n");
    printf("Vendor/Product ID: %04x:%04x\n", desc->idVendor,
	   desc->idProduct);

    usbio_main(dev);
}

檔案可由 [http://tw.jollen.org/findusb/] 下載。這裡提供一個 Makefile 檔案；編譯時，請記得安裝 libusb 並與 libusb 做連結。

* libusb API 文件. http://libusb.sourceforge.net/doc/

http://code.google.com/p/zhpy/

This wireless stack has many features, like a complete software MAC implementation, WEP, WPA, a "link-layer" bridging module, hostapd, QoS support to prioritize things like VoIP, 802.11g support, and full debug capabilities.

Another feature of this stack is a completely new user interface.

The disadvantage is the lack of drivers using this stack: the drivers that have been in the tree for a long time do not support this stack, and will need to be ported.

28 struct display_device;
29
30 /* This structure defines all the properties of a Display. */
31 struct display_driver {
32         int  (*set_contrast)(struct display_device *, unsigned int);
33         int  (*get_contrast)(struct display_device *);
34         void (*suspend)(struct display_device *, pm_message_t state);
35         void (*resume)(struct display_device *);
36         int  (*probe)(struct display_device *, void *);
37         int  (*remove)(struct display_device *);
38         int  max_contrast;
39 };
40
41 struct display_device {
42         struct module *owner;                   /* Owner module */
43         struct display_driver *driver;
44         struct device *parent;                  /* This is the parent */
45         struct device *dev;                     /* This is this display device */
46         struct mutex lock;
47         void *priv_data;
48         char type[16];
49         char *name;
50         int idx;
51 };
52
53 extern struct display_device *display_device_register(struct display_driver *driver,
54                                         struct device *dev, void *devdata);
55 extern void display_device_unregister(struct display_device *dev);