androidthreads

❶ android 播放音樂時為什麼用不到混音線程mixerthread

MixerThread是按照音頻輸出的核心部分，所有Android的音頻都需要經過MixerThread進行混音後再輸出到音頻設備。 MixerThread的繼承關系如下： MixerThread--->PlaybackThread--->ThreadBase--->Thread 在PlaybackThread中，重寫了Thread的threadLandroid 播放音樂時為什麼用不到混音線程mixerthread

❷ android中的線程池 怎麼用

java的線程池對Android也是適用的
線程池的作用：
線程池作用就是限制系統中執行線程的數量。
根據系統的環境情況，可以自動或手動設置線程數量，達到運行的最佳效果；少了浪費了系統資源，多了造成系統擁擠效率不高。用線程池控制線程數量，其他線程
排隊等候。一個任務執行完畢，再從隊列的中取最前面的任務開始執行。若隊列中沒有等待進程，線程池的這一資源處於等待。當一個新任務需要運行時，如果線程
池中有等待的工作線程，就可以開始運行了；否則進入等待隊列。
為什麼要用線程池:
1.減少了創建和銷毀線程的次數，每個工作線程都可以被重復利用，可執行多個任務。
2.可以根據系統的承受能力，調整線程池中工作線線程的數目，防止因為消耗過多的內存，而把伺服器累趴下(每個線程需要大約1MB內存，線程開的越多，消耗的內存也就越大，最後死機)。

Java通過Executors提供四種線程池，分別為：
newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。
newFixedThreadPool 創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。
newScheledThreadPool 創建一個定長線程池，支持定時及周期性任務執行。
newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

1.newCachedThreadPool

/**
* 可以緩存線程池
*/
public static void Function1() {
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 50; i++) {
final int index = i;
try {
Thread.sleep(100); // 休眠時間越短創建的線程數越多
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
executorService.execute(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("active count = " + Thread.activeCount()
+ " index = " + index);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
}

列印結果
active count = 2 index = 0
active count = 3 index = 1
active count = 4 index = 2
active count = 5 index = 3
active count = 6 index = 4
active count = 7 index = 5
active count = 8 index = 6
active count = 9 index = 7
active count = 10 index = 8
active count = 11 index = 9
active count = 11 index = 10
active count = 11 index = 11
active count = 11 index = 12
active count = 11 index = 13
active count = 11 index = 14
active count = 11 index = 15
active count = 11 index = 16
active count = 11 index = 17
active count = 11 index = 18
active count = 11 index = 19
active count = 11 index = 20
active count = 11 index = 21
active count = 11 index = 22
active count = 11 index = 23
active count = 11 index = 24
active count = 11 index = 25
active count = 11 index = 26
active count = 11 index = 27
active count = 11 index = 28
active count = 11 index = 29
active count = 11 index = 30
active count = 11 index = 31
active count = 11 index = 32
active count = 11 index = 33
active count = 11 index = 34
active count = 11 index = 35
active count = 11 index = 36
active count = 11 index = 37
active count = 11 index = 38
active count = 11 index = 39
active count = 11 index = 40
active count = 11 index = 41
active count = 11 index = 42
active count = 11 index = 43
active count = 11 index = 44
active count = 11 index = 45
active count = 11 index = 46
active count = 11 index = 47
active count = 11 index = 48
active count = 10 index = 49
從列印消息來看開始線程數在增加，後來穩定，可以修改休眠時間，休眠時間越短創建的線程數就越多，因為前面的還沒執行完，線程池中沒有可以執行的就需要創建；如果把休眠時間加大，創建的線程數就會少

2.newFixedThreadPool 根據傳入的參數創建線程數目
/**
* 定長線程池
*/
public static void Function2() {
ExecutorService executorService = Executors.newFixedThreadPool(3);
for (int i = 0; i < 30; i++) {
final int index = i;
executorService.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println("index = " + index
+ " thread count = " + Thread.activeCount());
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
}

3.newScheledThreadPool
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/**
* 定長線程池，可做延時
*/
public static void Function3() {
ScheledExecutorService executorService = Executors
.newScheledThreadPool(5);
executorService.schele(new Runnable() {

@Override
public void run() {
System.out.println("delay 3 seconds" + " thread count = "
+ Thread.activeCount());
}
}, 3, TimeUnit.SECONDS);
}

/**
* 定期執行，可以用來做定時器
*/
public static void Function4() {
ScheledExecutorService executorService = Executors
.newScheledThreadPool(3);
executorService.scheleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out
.println("delay 1 seconds, and excute every 3 seconds"
+ " thread count = " + Thread.activeCount());
}
}, 1, 3, TimeUnit.SECONDS);
}
列印結果
?

1
2
3
4
5
6
7
8
9

delay 1 seconds, and excute every 3 seconds thread count = 2
delay 1 seconds, and excute every 3 seconds thread count = 3
delay 1 seconds, and excute every 3 seconds thread count = 4
delay 1 seconds, and excute every 3 seconds thread count = 4
delay 1 seconds, and excute every 3 seconds thread count = 4
delay 1 seconds, and excute every 3 seconds thread count = 4
delay 1 seconds, and excute every 3 seconds thread count = 4
delay 1 seconds, and excute every 3 seconds thread count = 4
delay 1 seconds, and excute every 3 seconds thread count = 4

4.newSingleThreadExecutor這個最簡單
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

/**
* 單例線程
*/
public static void Function5() {
ExecutorService singleThreadExecutor = Executors
.newSingleThreadExecutor();
for (int i = 0; i < 5; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {

@Override
public void run() {
try {
System.out.println("index = " + index
+ " thread count = " + Thread.activeCount());
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
}

列印結果：
?

1
2
3
4
5

index = 0 thread count = 2
index = 1 thread count = 2
index = 2 thread count = 2
index = 3 thread count = 2
index = 4 thread count = 2

❸ android 群發簡訊時怎麼將數據插入到資料庫中 怎麼與非群發區分呢

Threads.getOrCreateThreadId(this, address) 群發傳入的address為 set<String>類型。

❹ Android上大文件分片上傳 具體怎麼弄

正常情況下，一般都是在長傳完成後，在伺服器直接保存。

?

1
2
3
4
5
6
7

public void ProcessRequest(HttpContext context)
{
context.Response.ContentType = "text/plain";
//保存文件
context.Request.Files[0].SaveAs(context.Server.MapPath("~/1/" + context.Request.Files[0].FileName));
context.Response.Write("Hello World");
}

最近項目中用網路開源的上傳組件webuploader，官方介紹webuploader支持分片上傳。具體webuploader的使用方法見官網http://fex..com/webuploader/。

?

1
2
3
4
5
6
7
8
9
10
11
12

var uploader = WebUploader.create({
auto: true,
swf:'/webuploader/Uploader.swf',
// 文件接收服務端。
server: '/Uploader.ashx',
// 內部根據當前運行是創建，可能是input元素，也可能是flash.
pick: '#filePicker',
chunked: true,//開啟分片上傳
threads: 1,//上傳並發數
//由於Http的無狀態特徵，在往伺服器發送數據過程傳遞一個進入當前頁面是生成的GUID作為標示
formData: {guid:"<%=Guid.NewGuid().ToString()%>"}
});

webuploader的分片上傳是把文件分成若干份，然後向你定義的文件接收端post數據，如果上傳的文件大於分片的尺寸，就會進行分片，然後會在post的數據中添加兩個form元素chunk和chunks,前者標示當前分片在上傳分片中的順序（從0開始），後者代表總分片數。

❺ Android的App中線程池的使用，具體使用多少個線程池

//在Android中實現線程池，首先需要實現一個線程工廠（ThreadFactory）的子類，具體實現方式如下所示（PriorityThreadFactory.Java）：
import android.os.Process;
/**
* A thread factory that create threads with a given thread priority
* @author jony
* @version 1.0
*/
public class PriorityThreadFactory implements ThreadFactory{
private final String mName;
private final int mPriority;
private final AtomicInteger mNumber = new AtomicInteger();

❻ android怎樣讀取sms資料庫指定欄位的數據

Android APK操作簡訊數據時，不能使用sqlHelper直接操作，需要使用協議，協議使用Uri轉義
content://sms/inbox 收件箱
content://sms/sent 已發送
content://sms/draft 草稿
content://sms/outbox 發件中
content://sms/failed 失敗
content://sms/queued 待發送
資料庫中sms相關的欄位如下：
_id primary key integer 與words表內的source_id關聯
thread_id 會話id，一個聯系人的會話一個id，與threads表內的_id關聯 integer
address 對方號碼 text
person 聯系人id integer
date 發件日期 integer
protocol 通信協議，判斷是簡訊還是彩信 integer 0：SMS_RPOTO, 1：MMS_PROTO
read 是否閱讀 integer default 0 0：未讀， 1：已讀
status 狀態 integer default-1 -1：接收，
0：complete,
64： pending,
128： failed
type 簡訊類型 integer 1：inbox
2：sent
3：draft56
4：outbox
5：failed
6：queued
body 內容
service_center 服務中心號碼
subject 主題
reply_path_present
locked
error_code
seen

具體使用方法：

Cursor cursor = mContentResolver.query(Uri.parse("content://sms"), String[] projection, String selection, String[] selectionArgs,String sortOrder);

if(cursor!=null)
if(cursor.moveToFirst())
{String address = cursor .getString(draftCursor.getColumnIndexOrThrow("address"));}

query轉義sql語句時將query函數中的參數轉義為
select projection[] from sms where selection[] = selectionArgs[] order by sortOrder

由於Android2.2 Messaging中存儲草稿簡訊時不會將address存入sms表中，而以thread_id為索引，將草稿簡訊的address存入canonical_addresses表中而導致僅根據協議無法查詢到draft msgs address（這種設計缺陷是因為Android為了使UI更加效率而使draft msgs不同於其他類型的msgs存儲方式所導致的），那麼根據這樣的轉義方式我們可以擴展一下這種select語句使他可以查詢到sms表以外的東西：

Cursor draftCursor = mResolver.query(Uri.parse("content://sms"),
new String[] {"canonical_addresses.address " +
"from sms,threads,canonical_addresses " +
"where sms.thread_id=threads._id and threads.recipient_ids=canonical_addresses._id and sms._id ='" +
String.valueOf(target_message_id) + "' --"},
null, null, null);

有點耍滑頭，是吧，用到了sql語句中注釋符號「--」
這樣我們就將這個語句轉化為了：
select canonical_addresses.address from sms,threads,canonical_addresses where sms.thread_id=threads._id and threads.recipient_ids=canonical_addresses._id and sms._id = 'target_message_id' -- from sms

在sql語句解析的時候，--from sms是不予解析的，所以就成功執行了前面的聯合查詢操作而得到了我們想要的canonical_addresses表中的address數據。

❼ android 基本文件操作命令

ADB (Android Debug Bridge)
說明：下面一些命令需要有root許可權才能執行成功
快速啟動dos窗口執行adb：
1. adb.exe所在路徑添加到系統環境變數中
2. 配置快捷鍵啟動dos
進入C:\WINDOWS\system32目錄下，找到cmd.exe.
右擊菜單 "發送到" -> 桌面快捷方式。
在桌面上右擊"快捷方式 到 cmd.exe" -> "屬性" -> "快捷方式"頁
-> 游標高亮"快捷鍵" -> 按下自定義快捷鍵 (如：Ctrl + Alt + Z)

任何情況下，按下Ctrl + Alt + Z啟動dos窗口就可以執行adb命令了

-----------查看設備連接狀態 系列-----------
adb get-serialno 獲取設備的ID和序列號serialNumber
adb devices 查詢當前計算機上連接那些設備（包括模擬器和手機），輸出格式: [serialNumber] [state]
adb get-state 查看模擬器/設施的當前狀態.

說明：
序列號[serialNumber]——由adb創建的一個字元串，這個字元串通過自己的控制埠<type>-<consolePort>
唯一地識別一個模擬器/設備實例。一個序列號的例子： emulator-5554

-----------發送命令到設備 系列-----------
adb [-d|-e|-s <serialNumber>] <command>
-d 發送命令給usb連接的設備
-e 發送命令到模擬器設備
-s <serialNumber> 發送命令到指定設備

如啟動手機設備shell: adb -d shell

adb forward <local> <remote>發布埠,可以設置任意的埠號，
做為主機向模擬器或設備的請求埠。如：adb forward tcp:5555 tcp:8000

adb reboot 重啟手機
adb remount 將system分區重新掛載為可讀寫分區
adb kill-server 終止adb服務進程
adb start-server 重啟adb服務進程
adb root 已root許可權重啟adb服務
adb wait-for-device 在模擬器/設備連接之前把命令轉載在adb的命令器中
adb jdwp 查看指定的設施的可用的JDWP信息.
可以用 forward jdwp:<pid> 埠映射信息來連接指定的JDWP進程.例如：
adb forward tcp:8000 jdwp:472
jdb -attach localhost:8000

adb shell am 命令可以啟動應用程序

adb shell input text <string> 向設備輸入文本（游標所在的文本框）
adb shell input keyevent <event_code> 向設備發送按鍵事件
如：
在編輯簡訊時，往文本框輸入文本：adb shell input text "hello"
向手機發送鍵值回Home：adb shell input keyevent 3
event_code 參考view/KeyEvent.java中的 KEYCODE_*
public static final int KEYCODE_SOFT_LEFT = 1;
public static final int KEYCODE_SOFT_RIGHT = 2;
public static final int KEYCODE_HOME = 3;
public static final int KEYCODE_BACK = 4;
public static final int KEYCODE_CALL = 5;
public static final int KEYCODE_ENDCALL = 6;

-----------安裝卸載 系列-----------
adb install [-l] [-r] <file> - push this package file to the device and install it
('-l' means forward-lock the app)
('-r' means reinstall the app, keeping its data)
adb uninstall [-k] <package> - remove this app package from the device
('-k' means keep the data and cache directories)
如：
adb install d:\hello.apk
adb unstall com.huawei.hello
說明：如果帶-r選項重新安裝apk時，安裝在 /data/local/tmp/目錄下，手機重啟後還是使用原來的apk.

-----------文件操作 系列-----------
adb push <local> <remote> - file/dir to device
adb pull <remote> <local> - file/dir from device

-----------基本linux shell命令 系列-----------
adb shell [command]
ls 列出目錄下的文件和文件夾
cd 切換目錄
rm 刪除目錄和文件
cat 查看文件內容
ps 可以看那個進程再跑
ps -x [PID] 查看單個進程的狀態
top 可以看那個進程的佔用率最高
su 切換到root用戶
kill [pid] 殺死一個進程
chmod 777 <file> 修改該文件為可執行許可權

詳細使用情況可以登錄一台Linux伺服器在shell下查看幫助手冊, man <command>

-----------查看系統狀態和信息 系列-----------
adb shell procrank 查詢各進程內存使用情況
adb shell service list 查看services信息
adb shell cat /proc/meminfo 查看當前的內存情況
adb shell cat /proc/cpuinfo 查看CPU信息（硬體）
adb shell cat /proc/iomem 查看IO內存分區

adb shell getprop 列出系統所有屬性
adb shell getprop | findstr "gsm" 列出包含gsm的屬性
adb shell setprop <key> <value> 修改系統屬性

adb shell sqlite3 可以執行sql語句查看資料庫信息， 具體使用情況待調查

-----------Log 系列-----------
adb logcat [ <filter-spec> ] - View device log

1~~~~~~~~~~~查看可用日誌緩沖區:
adb logcat -b radio — 查看緩沖區的相關的信息.
adb logcat -b events — 查看和事件相關的的緩沖區.
adb logcat -b main — 查看主要的日誌緩沖區

2~~~~~~~~~~~過濾日誌輸出:
過濾器語句按照下面的格式描tag:priority ... , tag 表示是標簽, priority 是表示標簽的報告的最低等級
adb logcat *:W 顯示優先順序為warning或更高的日誌信息
adb logcat ActivityManager:I MyApp:D *:S

日誌的標簽是系統部件原始信息的一個簡要的標志。（比如：「View」就是查看系統的標簽）.
優先順序有下列集中，是按照從低到高順利排列的:
V — Verbose (lowest priority)
D — Debug
I — Info
W — Warning
E — Error
F — Fatal
S — Silent (highest priority, on which nothing is ever printed)

如果你電腦上運行logcat ，相比在遠程adbshell端，你還可以為環境變數ANDROID_LOG_TAGS :輸入一個參數來設置默認的過濾
export ANDROID_LOG_TAGS="ActivityManager:I MyApp:D *:S"
需要注意的是ANDROID_LOG_TAGS 過濾器如果通過遠程shell運行logcat 或用adb shell logcat 來運行模擬器/設備不能輸出日誌.

3~~~~~~~~~~~控制日誌輸出格式:
日誌信息包括了許多元數據域包括標簽和優先順序。可以修改日誌的輸出格式，所以可以顯示出特定的元數據域。可以通過 -v 選項得到格式化輸出日誌的相關信息.

brief — Display priority/tag and PID of originating process (the default format).
process — Display PID only.
tag — Display the priority/tag only.
thread — Display process:thread and priority/tag only.
raw — Display the raw log message, with no other metadata fields.
time — Display the date, invocation time, priority/tag, and PID of the originating process.
long — Display all metadata fields and separate messages with a blank lines.
當啟動了logcat ，你可以通過-v 選項來指定輸出格式:

[adb] logcat [-v <format>]
下面是用 thread 來產生的日誌格式:

adb logcat -v thread
需要注意的是你只能-v 選項來規定輸出格式 option.

4~~~~~~~~~~~Logcat命令列表
-b <buffer> 載入一個可使用的日誌緩沖區供查看，比如event 和radio . 默認值是main 。具體查看Viewing Alternative Log Buffers.
-c 清楚屏幕上的日誌.
-d 輸出日誌到屏幕上.
-f <filename> 指定輸出日誌信息的<filename> ，默認是stdout .
-g 輸出指定的日誌緩沖區，輸出後退出.
-n <count> 設置日誌的最大數目<count> .，默認值是4，需要和 -r 選項一起使用。
-r <kbytes> 每<kbytes> 時輸出日誌，默認值為16，需要和-f 選項一起使用.
-s 設置默認的過濾級別為silent.
-v <format> 設置日誌輸入格式，默認的是brief 格式，要知道更多的支持的格式，參看Controlling Log Output Format

adb bugreport - return all information from the device
that should be included in a bug report.

adb shell dmesg 查詢內核緩沖區信息
adb shell mpstate 各類信息，比如進程信息，內存信息，進程是否異常，kernnel的log等
adb shell mpcrash
adb shell mpsys 查詢所有service的狀態

-----------其他 -----------

模擬器使用鏡像sdcard
用SDK里的mksdcard工具來創建FAT32磁碟鏡像並在模擬器啟動時載入它。這樣創建鏡像：? mksdcard <size> <file>,
比如我要創建一個64M的SD卡模擬文件，文件路徑是在D:\workspace\sdcard.img
mksdcard 64000000 D:\workspace\sdcard.img

Emulator –sdcard D:\workspace\sdcard.img
或者在eclipse的run菜單的open run dialog對話框中配置啟動參數。

#top
Usage: top [ -m max_procs ] [ -n iterations ] [ -d delay ] [ -s sort_column ] [ -t ] [ -h ]
-m num Maximum number of processes to display.
-n num Updates to show before exiting.
-d num Seconds to wait between updates.
-s col Column to sort by (cpu,vss,rss,thr).
-t Show threads instead of processes.
-h Display this help screen.

********* simple selection ********* ********* selection by list *********
-A all processes -C by command name
-N negate selection -G by real group ID (supports names)
-a all w/ tty except session leaders -U by real user ID (supports names)
-d all except session leaders -g by session OR by effective group name
-e all processes -p by process ID
T all processes on this terminal -s processes in the sessions given
a all w/ tty, including other users -t by tty
g OBSOLETE -- DO NOT USE -u by effective user ID (supports names)
r only running processes U processes for specified users
x processes w/o controlling ttys t by tty
*********** output format ********** *********** long options ***********
-o,o user-defined -f full --Group --User --pid --cols --ppid
-j,j job control s signal --group --user --sid --rows --info
-O,O preloaded -o v virtual memory --cumulative --format --deselect
-l,l long u user-oriented --sort --tty --forest --version
-F extra full X registers --heading --no-heading --context
********* misc options *********
-V,V show version L list format codes f ASCII art forest
-m,m,-L,-T,H threads S children in sum -y change -l format
-M,Z security data c true command name -c scheling class
-w,w wide output n numeric WCHAN,UID -H process hierarchy

netstat -ano 查看網路連狀態
顯示協議統計信息和當前 TCP/IP 網路連接。

NETSTAT [-a] [-b] [-e] [-n] [-o] [-p proto] [-r] [-s] [-v] [interval]

-a 顯示所有連接和監聽埠。
-b 顯示包含於創建每個連接或監聽埠的
可執行組件。在某些情況下已知可執行組件
擁有多個獨立組件，並且在這些情況下
包含於創建連接或監聽埠的組件序列
被顯示。這種情況下，可執行組件名
在底部的 [] 中，頂部是其調用的組件，
等等，直到 TCP/IP 部分。注意此選項
可能需要很長時間，如果沒有足夠許可權
可能失敗。
-e 顯示乙太網統計信息。此選項可以與 -s
選項組合使用。
-n 以數字形式顯示地址和埠號。
-o 顯示與每個連接相關的所屬進程 ID。
-p proto 顯示 proto 指定的協議的連接；proto 可以是
下列協議之一: TCP、UDP、TCPv6 或 UDPv6。
如果與 -s 選項一起使用以顯示按協議統計信息，proto 可以是下列協議之一:
IP、IPv6、ICMP、ICMPv6、TCP、TCPv6、UDP 或 UDPv6。
-r 顯示路由表。
-s 顯示按協議統計信息。默認地，顯示 IP、
IPv6、ICMP、ICMPv6、TCP、TCPv6、UDP 和 UDPv6 的統計信息；
-p 選項用於指定默認情況的子集。
-v 與 -b 選項一起使用時將顯示包含於
為所有可執行組件創建連接或監聽埠的
組件。
interval 重新顯示選定統計信息，每次顯示之間
暫停時間間隔(以秒計)。按 CTRL+C 停止重新
顯示統計信息。如果省略，netstat 顯示當前
配置信息(只顯示一次)

pm
usage: pm [list|path|install|uninstall]
pm list packages [-f]
pm list permission-groups
pm list permissions [-g] [-f] [-d] [-u] [GROUP]
pm list instrumentation [-f] [TARGET-PACKAGE]
pm list features
pm path PACKAGE
pm install [-l] [-r] [-t] [-i INSTALLER_PACKAGE_NAME] PATH
pm uninstall [-k] PACKAGE
pm enable PACKAGE_OR_COMPONENT
pm disable PACKAGE_OR_COMPONENT

The list packages command prints all packages. Options:
-f: see their associated file.

The list permission-groups command prints all known
permission groups.

The list permissions command prints all known
permissions, optionally only those in GROUP. Options:
-g: organize by group.
-f: print all information.
-s: short summary.
-d: only list dangerous permissions.
-u: list only the permissions users will see.

The list instrumentation command prints all instrumentations,
or only those that target a specified package. Options:
-f: see their associated file.

The list features command prints all features of the system.

The path command prints the path to the .apk of a package.

The install command installs a package to the system. Options:
-l: install the package with FORWARD_LOCK.
-r: reinstall an exisiting app, keeping its data.
-t: allow test .apks to be installed.
-i: specify the installer package name.

The uninstall command removes a package from the system. Options:
-k: keep the data and cache directories around.
after the package removal.

The enable and disable commands change the enabled state of
a given package or component (written as "package/class").

查看stdout 和stderr
在默認狀態下，Android系統有stdout 和 stderr (System.out和System.err )輸出到/dev/null ，
在運行Dalvik VM的進程中，有一個系統可以備份日誌文件。在這種情況下，系統會用stdout 和stderr 和優先順序 I.來記錄日誌信息

通過這種方法指定輸出的路徑，停止運行的模擬器/設備，然後通過用setprop 命令遠程輸入日誌

$ adb shell stop
$ adb shell setprop log.redirect-stdio true
$ adb shell start系統直到你關閉模擬器/設備前設置會一直保留，可以通過添加/data/local.prop 可以使用模擬器/設備上的默認設置

UI/軟體 試驗程序 Monkey
當Monkey程序在模擬器或設備運行的時候，如果用戶出發了比如點擊，觸摸，手勢或一些系統級別的事件的時候，
它就會產生隨機脈沖，所以可以用Monkey用隨機重復的方法去負荷測試你開發的軟體.
最簡單的方法就是用用下面的命令來使用Monkey，這個命令將會啟動你的軟體並且觸發500個事件.

$ adb shell monkey -v -p your.package.name 500
更多的關於命令Monkey的命令的信息，可以查看UI/Application Exerciser Monkey documentation page.

❽ 如何在android的jni線程中實現回調

JNI回調是指在c/c++代碼中調用java函數，當在c/c++的線程中執行回調函數時，會導致回調失敗。

其中一種在Android系統的解決方案是：

把c/c++中所有線程的創建，由pthread_create函數替換為由Java層的創建線程的函數AndroidRuntime::createJavaThread。

假設有c++函數:

[cpp] view plain
void *thread_entry(void *args)
{
while(1)
{
printf("thread running...\n");
sleep(1);
}

}

void init()
{
pthread_t thread;
pthread_create(&thread,NULL,thread_entry,(void *)NULL);
}

init()函數創建一個線程，需要在該線程中調用java類Test的回調函數Receive:

[cpp] view plain
public void Receive(char buffer[],int length){
String msg = new String(buffer);
msg = "received from jni callback:" + msg;
Log.d("Test", msg);
}

首先在c++中定義回調函數指針：

[cpp] view plain
//test.h
#include <pthread.h>
//function type for receiving data from native
typedef void (*ReceiveCallback)(unsigned char *buf, int len);

/** Callback for creating a thread that can call into the Java framework code.
* This must be used to create any threads that report events up to the framework.
*/
typedef pthread_t (* CreateThreadCallback)(const char* name, void (*start)(void *), void* arg);

typedef struct{
ReceiveCallback recv_cb;
CreateThreadCallback create_thread_cb;
}Callback;

再修改c++中的init和thread_entry函數：

[cpp] view plain
//test.c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/wait.h>
#include <unistd.h>
#include "test.h"

void *thread_entry(void *args)
{
char *str = "i'm happy now";
Callback cb = NULL;
int len;
if(args != NULL){
cb = (Callback *)args;
}

len = strlen(str);
while(1)
{
printf("thread running...\n");
//invoke callback method to java
if(cb != NULL && cb->recv_cb != NULL){
cb->recv_cb((unsigned char*)str, len);
}
sleep(1);
}

}

void init(Callback *cb)
{
pthread_t thread;
//pthread_create(&thread,NULL,thread_entry,(void *)NULL);
if(cb != NULL && cb->create_thread_cb != NULL)
{
cb->create_thread_cb("thread",thread_entry,(void *)cb);
}
}

然後在jni中實現回調函數，以及其他實現：

[cpp] view plain
//jni_test.c
#include <stdlib.h>
#include <malloc.h>
#include <jni.h>
#include <JNIHelp.h>
#include "android_runtime/AndroidRuntime.h"

#include "test.h"
#define RADIO_PROVIDER_CLASS_NAME "com/tonny/Test"

using namespace android;

static jobject mCallbacksObj = NULL;
static jmethodID method_receive;

static void (JNIEnv* env, const char* methodName) {
if (env->ExceptionCheck()) {
LOGE("An exception was thrown by callback '%s'.", methodName);
LOGE_EX(env);
env->ExceptionClear();
}
}

static void receive_callback(unsigned char *buf, int len)
{
int i;
JNIEnv* env = AndroidRuntime::getJNIEnv();
jcharArray array = env->NewCharArray(len);
jchar *pArray ;

if(array == NULL){
LOGE("receive_callback: NewCharArray error.");
return;
}

pArray = (jchar*)calloc(len, sizeof(jchar));
if(pArray == NULL){
LOGE("receive_callback: calloc error.");
return;
}

// buffer to jchar array
for(i = 0; i < len; i++)
{
*(pArray + i) = *(buf + i);
}
// buffer to jcharArray
env->SetCharArrayRegion(array,0,len,pArray);
//invoke java callback method
env->CallVoidMethod(mCallbacksObj, method_receive,array,len);
//release resource
env->DeleteLocalRef(array);
free(pArray);
pArray = NULL;

(env, __FUNCTION__);
}

static pthread_t create_thread_callback(const char* name, void (*start)(void *), void* arg)
{
return (pthread_t)AndroidRuntime::createJavaThread(name, start, arg);
}

static Callback mCallbacks = {
receive_callback,
create_thread_callback
};

static void jni_class_init_native
(JNIEnv* env, jclass clazz)
{
method_receive = env->GetMethodID(clazz, "Receive", "([CI)V");
}

static int jni_init
(JNIEnv *env, jobject obj)
{

if (!mCallbacksObj)
mCallbacksObj = env->NewGlobalRef(obj);

return init(&mCallbacks);
}

static const JNINativeMethod gMethods[] = {
{ "class_init_native", "()V", (void *)jni_class_init_native },
{ "native_init", "()I", (void *)jni_init },
};

static int registerMethods(JNIEnv* env) {

const char* const kClassName = RADIO_PROVIDER_CLASS_NAME;
jclass clazz;
/* look up the class */
clazz = env->FindClass(kClassName);
if (clazz == NULL) {
LOGE("Can't find class %s/n", kClassName);
return -1;
}
/* register all the methods */
if (env->RegisterNatives(clazz,gMethods,sizeof(gMethods)/sizeof(gMethods[0])) != JNI_OK)
{
LOGE("Failed registering methods for %s/n", kClassName);
return -1;
}
/* fill out the rest of the ID cache */
return 0;
}

jint JNI_OnLoad(JavaVM* vm, void* reserved) {
JNIEnv* env = NULL;
jint result = -1;
LOGI("Radio JNI_OnLoad");
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
LOGE("ERROR: GetEnv failed/n");
goto fail;
}

if(env == NULL){
goto fail;
}
if (registerMethods(env) != 0) {
LOGE("ERROR: PlatformLibrary native registration failed/n");
goto fail;
}
/* success -- return valid version number */
result = JNI_VERSION_1_4;
fail:
return result;
}

jni的Android.mk文件中共享庫設置為：

[cpp] view plain
LOCAL_SHARED_LIBRARIES := liblog libcutils libandroid_runtime libnativehelper

最後再實現Java中的Test類：

[java] view plain
//com.tonny.Test.java

public class Test {

static{
try {
System.loadLibrary("test");
class_init_native();

} catch(UnsatisfiedLinkError ule){
System.err.println("WARNING: Could not load library libtest.so!");
}

}

public int initialize() {
return native_radio_init();
}

public void Receive(char buffer[],int length){
String msg = new String(buffer);
msg = "received from jni callback" + msg;
Log.d("Test", msg);
}

protected static native void class_init_native();

protected native int native_init();

}

❾ 如何分析解決Android ANR

一：什麼是ANR

ANR:Application Not Responding，即應用無響應二：ANR的類型

ANR一般有三種類型：

1：KeyDispatchTimeout(5 seconds) --主要類型

按鍵或觸摸事件在特定時間內無響應

2：BroadcastTimeout(10 seconds)

BroadcastReceiver在特定時間內無法處理完成

3：ServiceTimeout(20 seconds) --小概率類型

Service在特定的時間內無法處理完成三：KeyDispatchTimeout

Akey or touch event was not dispatched within the specified time（按鍵或觸摸事件在特定時間內無響應）

具體的超時時間的定義在framework下的

ActivityManagerService.java

//How long we wait until we timeout on key dispatching.

staticfinal int KEY_DISPATCHING_TIMEOUT = 5*1000四：為什麼會超時呢？

超時時間的計數一般是從按鍵分發給app開始。超時的原因一般有兩種：

(1)當前的事件沒有機會得到處理（即UI線程正在處理前一個事件，沒有及時的完成或者looper被某種原因阻塞住了）

(2)當前的事件正在處理，但沒有及時完成五：如何避免KeyDispatchTimeout

1：UI線程盡量只做跟UI相關的工作

2：耗時的工作（比如資料庫操作，I/O，連接網路或者別的有可能阻礙UI線程的操作）把它放入單獨的線程處理

3：盡量用Handler來處理UIthread和別的thread之間的交互六：UI線程

說了那麼多的UI線程，那麼哪些屬於UI線程呢？

UI線程主要包括如下：

Activity:onCreate(), onResume(), onDestroy(), onKeyDown(), onClick(),etc

AsyncTask: onPreExecute(), onProgressUpdate(), onPostExecute(), onCancel,etc

Mainthread handler: handleMessage(), post*(runnable r), etc

other
從LOG可以看出ANR的類型，CPU的使用情況，如果CPU使用量接近100%，說明當前設備很忙，有可能是CPU飢餓導致了ANR

如果CPU使用量很少，說明主線程被BLOCK了

如果IOwait很高，說明ANR有可能是主線程在進行I/O操作造成的

除了看LOG，解決ANR還得需要trace.txt文件，

如何獲取呢？可以用如下命令獲取

$chmod 777 /data/anr

$rm /data/anr/traces.txt

$ps

$kill -3 PID

adbpull data/anr/traces.txt ./mytraces.txt

從trace.txt文件，看到最多的是如下的信息：

-----pid 21404 at 2011-04-01 13:12:14 -----
Cmdline: com.android.email

DALVIK THREADS:
(mutexes: tll=0tsl=0 tscl=0 ghl=0 hwl=0 hwll=0)
"main" prio=5 tid=1NATIVE
| group="main" sCount=1 dsCount=0obj=0x2aad2248 self=0xcf70
| sysTid=21404 nice=0 sched=0/0cgrp=[fopen-error:2] handle=1876218976
atandroid.os.MessageQueue.nativePollOnce(Native Method)
atandroid.os.MessageQueue.next(MessageQueue.java:119)
atandroid.os.Looper.loop(Looper.java:110)
at android.app.ActivityThread.main(ActivityThread.java:3688)
at java.lang.reflect.Method.invokeNative(Native Method)
atjava.lang.reflect.Method.invoke(Method.java:507)
atcom.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:866)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:624)
at dalvik.system.NativeStart.main(Native Method)

說明主線程在等待下條消息進入消息隊列

❿ android 線程池有什麼用

//在Android中實現線程池，首先需要實現一個線程工廠（ThreadFactory）的子類，具體實現方式如下所示（PriorityThreadFactory.Java）：
import android.os.Process;
/**
* A thread factory that create threads with a given thread priority
* @author jony
* @version 1.0
*/
public class PriorityThreadFactory implements ThreadFactory{
private final String mName;
private final int mPriority;
private final AtomicInteger mNumber = new AtomicInteger();

public PriorityThreadFactory(String name, int priority) {
mName = name;// 線程池的名稱
mPriority = priority;//線程池的優先順序
}
@Override
public Thread newThread(Runnable r) {
return new Thread(r, mName +"-"+mNumber.getAndIncrement()){
@Override
public void run() {
// 設置線程的優先順序
Process.setThreadPriority(mPriority);
super.run();
}
};
}
}
//以上是創建線程池的一個工具類，接下來為大家介紹本篇文章的重點，線程池的實現方式，具體實現方式如下所示（MyThreadPool.java）：
package com.tcl.actionbar;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
package com.tcl.actionbar;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ThreadFactory;

// 線程池的實現方式
public class MyThreadPool {
private final static int POOL_SIZE = 4;// 線程池的大小最好設置成為CUP核數的2N
private final static int MAX_POOL_SIZE = 6;// 設置線程池的最大線程數
private final static int KEEP_ALIVE_TIME = 4;// 設置線程的存活時間
private final Executor mExecutor;
public MyThreadPool() {
// 創建線程池工廠
ThreadFactory factory = new PriorityThreadFactory("thread-pool", android.os.Process.THREAD_PRIORITY_BACKGROUND);
// 創建工作隊列
BlockingQueue<Runnable> workQueue = new LinkedBlockingDeque<Runnable>();
mExecutor = new ThreadPoolExecutor(POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS, workQueue, factory);
}
// 在線程池中執行線程
public void submit(Runnable command){
mExecutor.execute(command);
}
}