Android2011. 4. 22. 14:30

Android app build system : Build from Command Line


Ant build script로 애플리케이션을 빌드하는 방법은 debug mode와 release mode가 있다.
어떤 방법을 사용하던간에 애뮬레이터나 디바이스에서 동작시키려면 signing을 해야 한다.

debug mode로 빌드시 Ant는 debug key로 자동으로 sign한다. 따라서 애뮬이나 디바이스에서 구동 가능하다. 하지만 배포는 불가하다. 릴리즈모드로 빌드하면 unsigned apk 가 만들어진다. 따라서 반드시 private key로 keytool과 jarsigner로 sign해야 한다.

Ant가 설치되어 있지 않다면 Apache Ant home page로부터 설치를 해야 한다. 그리고 실행경로를 설정해야 한다. JAVA_HOME환경변수가 JDK가 설치된 경로를 지정하고 있어야 한다.

윈도우에서는 JDK가  "Program FIles"폴더에 설치되는데 공백때문에 오류가 날수 있으므로 아래와 같이 정의한다.
set JAVA_HOME=c:\Progra~1\Java\<jdkdir>

debug mode로 빌드하는 방법은 프로젝트의 루트위치에서 아래 명령만 치면 된다.

ant debug

이 명령은 bin/ 위치에 여러분의 애플리케이션 .apk파일을 만들어준다. 이 파일은 애뮬이나 디바이스에 바로 설치 및 디버깅이 가능하다.

소스가 변경될 때 마다 이 명령을 수행하여 재빌드한다.

release mode로 빌드하는 방법은 프로젝트의 루트위치에서 아래 명령만 치면 된다.

ant release

이 명령으로 생성된 .apk file은 unsigned apk이다.
따라서 signing과 zipalign을 추가로 해주어야 한다. 이 과정까지 마치면 배포를 위한 준비를 마친게 된다.

원한다면 Android build script가 자동으로 sign하고 align하도록 할 수 있다. keystore와 key alias를 build.properties 파일에 기술하면된다. 이 정보가 존재하면 빌드스크립트는 keystore와 alias password를 입력하는 화면이 나오게 된다.

주의 : Ant가 입력을 다룰수 있기 때문에 빌드프로세싱중 패스워드가 화면에 보여질수 있다. 이게 거슬린다면 매뉴얼로 signing하는것이 좋다. manual로 signing하는것 대신에 unsigned로 빌드 후 signing을 별도로 하면된다.

build.properties에는 아래와 같이 keystore와 alias name을 지정할 수 있다.

key.store=path/to/my.keystore
key.alias=mykeystore

위와 같이 한 수 재빌드하면 sign된 릴리즈모드 apk가 만들어진다.

빌드를 완전히 자동화할 목적으로 사용하고자 한다면 signing중에 password입력 프롬프트가 뜨는것을 부담스러워 할 수 있다.
이 때는 수동으로 해야 하는데 jarsigner에서 수동으로 password를 지정할 수 있다. 위에서 기술한 build.properties방식으로는 동작하지 않으므로 별도로 매뉴얼로 수행해야 한다.

jarsigner -verbose \
             -keystore my-release-key.keystore  \   <- keystore file의 full path
             -storepass 1234 \        <- keystore의 password
             myapp.apk \                <- unsigned apk
             myalias_name                   <- keystore의 alias name

위의 예처럼 하면 프롬프트 없이 signing이 완료된다.



 
Posted by 삼스
Android2011. 4. 22. 12:21

Android app build system : Building and Running


개요
안드로이드 애플리케이션은 빌드가 되면 apk파일로 압축된 바이너리파일로 만들어진다.
apk는 Dalvic byte code로 변환된 자바클래스파일인 dex file들, 바이너리버전의 AndroidManifest.xml, 컴파일된 리소스파일들(resources.arsc)와 컴파일되지 않는 리소스파일들로 구성된다.
 
이클립스에서 개발한다면 ADT 플러그인이 자동으로 관리한다.
이클립스가 아닌 개발환경에서는 프로젝트 디렉토리상의 build.xml을 이용하여 Ant로 빌드할 수 있다.

에뮬레이터나 디바이스에서 동작시키려면 애플리케이션을 반드시 signing해야 한다. 이클립스와 앤트를 이용하여 이 과정도 쉽게 할 수 있다.

다음 그림은 빌드와 실행까지의 과정을 보여준다.
 
빌드프로세스의 상세

빌드프로세스에는 많은 툴들과 프로세스들이 apk파일을 만들기 위해 임시파일들을 생성하게 된다. 이클립스를 사용중이라면 모든 빌드프로세스가 코드를 저장하는 순간 이 과정이 자동으로 이루어진다. 다른 IDE를 사용한다면 이 과정들이 ANT build script가 수행되는 순간 이루어진다. 




일반적인 빌드 프로세스는 아래의 순서로 이루어진다.

1. Android Asset Packaging Tool(aapt)가 애플리케이션의 리소스파일들(AndroidManifest.xml, other XML files)들을 수집하여 컴파일하여 R.java파일을 만들어낸다. 이 파일은 자바코드로 추가되어 컴파일하는데 레퍼런스로 사용된다.
2. aidl tool은 .aidl파일들을 찾아서 모두 java파일로 변환 생성한다.
3. 모든 자바코드, R.java, .aidl파일들이 자바컴파일러에 의해 컴파일되어 .class파일들을 만들어낸다.
4. dex tool이 class파일들을  .dex파일로 변환한다. 3rd party library와 프로젝트에 포함된 모든 .class파일들도 함께 .dex로 변환된다.
5. 모든 컴파일되지 않는 리소스들(이미지등..), 컴파일된 리소스들 그리고 .dex 파일들이 apkbuilder tool에 의해 .apk파일로 패키징된다.
6. .apk파일이 한번 빌드되면, 디버그나 릴리즈 키스토어로 반드시 사인되어야 한다. 그래야 디바이스에 설치가 된다.
7. 최종적으로 릴리즈모드로 사인되었다면 zipalign으로 align을 해야 한다. aligning은 애플리케이션이 디바이스에서 동작할 때
메모리 사용량을 최소한으로 줄여준다.

Posted by 삼스
Linux2011. 4. 6. 17:19

gdb 명령어.

출처 : http://hongten.egloos.com/416241

1. 우선 컴파일 시에 디버깅 정보를 담아야 한다.
gcc -g -o [프로그램명] [소스파일명]
디버깅 옵션인 -g 으로 컴파일하며, 최적화 옵션인 -O 은 주지 않도록 한다.

2. 실행방법
gdb [프로그램명]
gdb [프로그램명] [core파일명]
gdb [프로그램명] [실행중인프로세스pid]

3. 종료방법
q
Ctrl + d

4. 소스 찾아가기 (list)
l : main 함수를 기점으로 소스의 내용이 출력된다
l 10 : 10 행 주변의 소스가 출력되는데 10 - 5 행부터 10 + 5행까지 총 10행이 출려된다.
l func : func 함수의 소스를 출력
l -5 : 기본값으로 10줄이 출력된다고 가정하고, 다음에 출력될 라인이 11라인이라면, 10(마지막라인) - 5 라인을 중심으로 출력된다. 즉, 그대로 1~10라인이 출력된다.
l a.c:func : a.c 파일의 func 함수부분을 출력
l a.c:10 : a.c 파일의 10행을 기준으로 출력

5. 옵션
set listsize 20 : 한번에 출력하는 행의 갯수를 20개로 늘린다.
Enter : 마지막으로 수행한 명령어를 다시 수행한다

6. 프로그램 실행, 종료 (run, kill)
r : 프로그램 수행 (재시작)
r arg1 arg2 : arg1과 arg2를 인자로 프로그램 수행
k : 프로그램 수행종료

7. 역추적하기 (backtrace)
bt : 오류가 발생한 함수를 역으로 찾아간다.

8. 중단점 사용하기 (breakpoint, temporary breakpoint)
b func : func 함수에 브레이크 포인트 설정
b 10 : 10행에 브레이크 포인트 설정
b a.c:func : a.c파일의 func함수에 브레이크 포인트 설정
b a.c:10 : a.c파일의 10행에 브레이크 포인트 설정
b +2 : 현재 행에서 2개 행 이후 지점에 브레이크 포인트 설정
b -2 : 현재 행에서 2개 행 이전 지점에 브레이크 포인트 설정
b *0x8049000 : 0x8049000 주소에 브레이크 포인트 설정 (어셈블리로 디버깅 시 사용)
b 10 if var == 0 : 10행에 브레이크 포인트를 설정해되, var 변수 값이 0일 때 작동
tb : 임시 중단점을 사용하는 것으로 한번만 설정되며, 그 이후에는 삭제된다.

9. 중단점 설정하기 (condition)
condition 2 var == 0 : 고유번호가 2번인 브레이크포인트에 var변수가 0일 때 동작하라고 설정

10. 중단점 삭제하기 (clear, delete)
cl func : func 함수의 시작 부분에 브레이크 포인트 지움
cl 10 : 10행의 브레이크 포인트 지움
delete 1 : 고유번호 1번의 브레이크 포인트를 지운
cl a.c:func : a.c 파일의 func함수의 브레이크 포인트 지움
cl a.c:10 : a.c 파일의 10행의 브레이크 포인트 지움
cl : 모든 브레이크 포인트 지움 

11. 중단점 정보보기 (information)
info b : 현재 설정된 브레이크 포인트의 정보를 보여준다
방향키Up/Down : 방향키 Up/Down을 누르면 히스토리 기능을 제공한다
info br + TAB : info br 로 시작하는 키워드가 히스토리에 있다면 뿌려준다
info TAB + TAB : info 뒤에 올 수 있는 인자 리스트를 보여준다
TAB + TAB : 현재 사용가능한 모든 명령어 리스트를 보여준다

12. 중단점 비활성화, 활성화 하기 (enable, disable)
disable 2 : 고유번호 2번인 브레이크 포인트 비활성화
enable 2 : 고유번호 2번인 브레이크 포인트 활성화

13. 디버깅 하기 (step, next, continue, until, finish, return, step instruction, next instruction)
s : 현재 출력된 행을 수행하고 멈추지만, 함수의 경우 함수의 내부로 들어가서 수행된다
s 5 : s를 5번 입력한 것과 동일
n : 현재 행을 수행하고 멈추지만, 함수의 경우 함수를 수행하고 넘어간다
n 5 : n을 5번 입력한 것과 동일
c : 다음 브레이크 포인트를 만날때 까지 계속 수행한다
u : for 문에서 빠져나와서 다음 브레이크 포인트까지 수행한다.
finish : 현재 함수를 수행하고 빠져나감
return : 현재 함수를 수행하지 않고 빠져나감
return 123 : 현재 함수를 수행하지 않고 빠져나감, 단, 리턴값은 123
si : 현재의 인스트럭션을 수행, 함수 호출 시 내부로 들어간다.
ni : 현재의 인스트럭션을 수행, 함수 호출 시 내부로 들어가지 않는다.

14. 감시점 설정 (watch)
watch i : i변수에 와치포인트를 설정하고 i변수가 바뀔 때마다 브레이크가 걸리면서 이전값과 현재값을 출력한다.

15. 변수 정보보기 (info, print)
info locals : 현재 상태에서 어떤 지역변수들이 있으며, 값은 어떠한지를 알 수 있다.
info variables : 현재 상태에서의 전역변수 리스트를 확인할 수 있다.
p lval : lval 값을 확인한다.
p func : func 함수의 주소값을 확인한다.
p pt : pt가 구조체라면 구조체의 주소를 확인한다
p *pt : pt가 구조체라면 구조체의 값을 확인한다.
p **pt : *pt가 구조체라면 구조체의 값을 확인한다.
info registers : 레지스트 값 전체를 한번에 확인한다.

16. 레지스트 값 및 포인터가 가리키는 구조체의 배열을 출력 (info, print)
info all-registers : MMX 레지스트를포함하여 거의 대부분의 레지스트 값을 확인한다.
p $eax : eax 레지스트의 값을 확인한다. ( ex_ eax, ebx, ecx, edx, eip ) 
p *pt@4 : 4크기의 배열로 gdb가 알 수 있으므로 4개의 크기만큼 가져와서 확인할 수 있다.

17. 중복된 변수명이 있는 경우 특정 변수를 지정해서 출력 (print)
p 'main.c'::var : main.c 파일에 있는 전역변수인 var 변수의 값을 출력
p hello::var : hello 함수에 포함된 static 변수인 var 변수의 값을 출력

18. 출력 형식의 지정
p/t var : var 변수를 2진수로 출력
p/o var : var 변수를 8진수로 출력
p/d var : var 변수를 부호가 있는 10진수로 출력 (int)
p/u var : var 변수를 부호가 없는 10진수로 출력 (unsigned int)
p/x var : var 변수를 16진수로 출력
p/c var : var 변수를 최초 1바이트 값을 문자형으로 출력
p/f var : var 변수를 부동 소수점 값 형식으로 출력
p/a addr : addr주소와 가장 가까운 심볼의 오프셋을 출력 ( ex_ main + 15 )

19. 타입이 틀릴 경우 타입을 변환하여 출력
p (char*)vstr : 실제 컴파일 시에 (void *)형으로 되어있었다고 하더라도 (char *)로 캐스팅 하여 보여줌

20. 특정한 위치 지정
p lstr + 4 : 예를 들어 lstr = "I like you." 라는 문자열은 "ke you."가 출력된다.

21. 변수 값 설정
p lval = 1000 : 변수값 확인 이외에는 설정도 가능하다.

22. 출력명령 요약 (print)
p [변수명] : 변수 값을 출력
p [함수명] : 함수의 주소를 출력
p/[출력형식] [변수명] : 변수 값을 출력 형식으로 출력
p '[파일명]'::[변수명] : 파일명에 있는 전역변수 값을 출력
p [함수명]::[변수명] : 함수에 있는 변수 값을 출력
p [변수명]@[배열크기] : 변수의 내용을 변수 배열의 크기 형태로 출력

23. 디스플레이 명령 (display, undisplay)
display [변수명] : 변수 값을 매번 화면에 디스플레이
display/[출력형식] [변수명] : 변수 값을 출력 형식으로 디스플레이
undisplay [디스플레이번호] : 디스플레이 설정을 없앤다
disable display [디스플레이번호] : 디스플레이를 일시 중단한다.
enable display [디스플레이번호] : 디스플레이를 다시 활성화한다.

24. 스택이란
스택의 경우는 상위 1기가는 커널에서 사용하며, 그 바로 아래 공간인 상위 0xBFFFFFFF 부터 하위로 늘어나게된다.
상세한 디버깅을 위해서는 -g 옵션으로 디버깅 정보와 --save-temps 옵션을 통해 어셈블리 코드를 얻어낼 수 있다.
상위 프레임으로 갈 수록 메인 함수에 가까워 지는 것이다.

25. 스택 프레임 관련 명령 (frame, up, down, info)
frame [N] : n번 스택 프레임으로 변경
up : 상위 프레임으로 이동
up [N] : n번 상위 스택 프레임으로 이동
down : 하위 프레임으로 이동
down [N] : n번 하위 스택 프레임으로 이동
info frame : 현재 스택 프레임 정보를 출력
info args : 현재 스택 프레임의 함수가 호출될 때 인자를 출력
info locals : 현재 스택 프레임의 함수내의 지역변수를 출력
info catch : 현재 스택 프레임의 함수내의 예외 핸들러를 출력

26. 스택 트레이스 하는법
b main 또는 원하는 곳에 브레이크 포인트를 잡고
오류가 발생할 때 까지 c를 통해 진행하면, 세그먼트 폴트 등의 오류가 발생하고 디버그가 멈추는데
여기서 bt 를 통해서 전체 스택 프레임을 확인하고 어떤 함수에서 호출시에 문제가 발생하였는지 확인
단, 일반적인 라이브러리에서는 오류발생 확률이 없다고 보고, 그 함수를 호출시에 문제를 의심한다.
다시 프레임을 이동하면서, 로컬변수와 전역변수 등을 확인하면서 디버깅이 가능하다.

27. 메모리 상태 검사 (x)
x/[범위][출력 형식][범위의 단위] : 메모리의 특정 범위의 값들을 확인할 수 있다.
이렇게 메모리를 직접 읽어보는 일은 -g 옵션을 가지고 컴파일 되지 않은 실행파일을 디버깅 할때에 자주 사용된다.
즉, x/10i main 과 같이 역 어셈블하여 해당 코드를 추측하는 것이다.

28. 출력형식
x/10 main : main 함수 시작부터 40바이트를 출력한다. 출력형식은 다음과 같다.
x/10t main : main 함수 시작부터 40바이트를 2진수로 출력
x/10o main : main 함수 시작부터 40바이트를 8진수로 출력
x/10d main : main 함수 시작부터 40바이트를 부호가 있는 10진수로 출력 (int)
x/10u main : main 함수 시작부터 40바이트를 부호가 없는 10진수로 출력 (unsigned int)
x/10x main : main 함수 시작부터 40바이트를 16진수로 출력
x/10c main : main 함수 시작부터 40바이트를 최초 1바이트 값을 문자형으로 출력
x/10f main : main 함수 시작부터 40바이트를 부동 소수점 값 형식으로 출력
x/10a main : 가장 가까운 심볼의 오프셋을 출력
x/10s main : 문자열로 출력
x/10i main : 어셈블리 형식으로 출력

29. 범위의 단위 (기본 word - 4바이트)
x/10b main : byte - 1바이트 단위 - 10바이트 출력
x/10h main : halfword - 2바이트 단위 - 20바이트 출력
x/10w main : word - 4바이트 단위 - 40바이트 출력
x/10g main : giant word - 8바이트 단위 - 80바이트 출력

30. 디스어셈블링 (disas)
disas func : 어셈블리 코드를 좀 보편적으로 보기 위한 명령어
disas 0x8048300 0x8048400 : 특정 주소 범위사이의 어셈블리 코드를 보기

31. 함수호출 (call)
call func(arg1, arg2) : 특정함수 func를 arg1, arg2 파라메터를 포함하여 호출하고, 반환값은 출력

32. 점프 (jump)
jump *0x08048321 : 해당 주소로 무조건 분기하여 인스트럭션을 계속 수행한다.
jump 10 : 무조건 10행으로 분기하여 수행한다.
jump func : func 함수로 무조건 분기하여 수행한다.

33. 시그널 전송 (signal)
info signals : 보낼 수 있는 시그널의 종류를 확인할 수 있다.
signal SIGKILL : 디버깅 대상의 프로세스에게 KILL 시그널을 보낼 수 있다.

34. 메모리의 특정 영역에 값을 설정 ( set )
set {타입}[주소] = [값] : p 명령 대신에 set 을 통해서 메모리의 특정 주소에 저장하는 것이 더 일반적이다
set {int}0x8048300 = 100 : 해당 주소에 100의 값을 입력한다.

35. gdb 환경설정 (set)
info set : 변경 가능한 환경설정 정보를 출력한다.
info functions : 함수들의 리스트를 출력
info types : 선언된 타입에 대한 리스트를 출력
set prompt psyoblade: : 프롬프트를 psyoblade: 로 변경할 수 있다.
set print array on : 배열을 출력할 때 한 행에 출력하는 것이 아니라 여러 행에 출력한다.

36. 기타 info 를 통해 알 수 있는 정보들
address catch extensions handle objects set stack tracepoints
all-registers common files heap program sharedlibrary symbol types
architecture copying float leaks registers signals target variables
args dcache frame line remote-process source terminal warranty
breakpoints display functions locals scope sources threads watchpoints
Posted by 삼스
Android/App개발2011. 3. 31. 18:55

android JNI debug를 위해 ndk-gdb가 안되는 이유


JNI function을 테스트하기 위해 ndk-gdb를 사용하려고 하는데 에뮬레이터가 아닌 상용단말에서 안되는 경우가 있다.
내 경우 HTC Desire에서 동작하지 않았다.

이유를 찾아보니 shell 명령중에 run-as가 정상동작하지 않도록 해놓았단다.

이런 젝일...
갤럭시S도 그렇다는데 되는 디바이스가 있을지 모르겠다.. 
넥서스시리즈는 될까???

혹시 이글 읽고 다른 디바이스에서 되는 분 있으면 댓글 좀...

원문 출처: http://groups.google.com/group/android-ndk/tree/browse_frm/month/2011-03/1ce4f2052e3378db?rnum=41&_done=%2Fgroup%2Fandroid-ndk%2Fbrowse_frm%2Fmonth%2F2011-03%3F

It's a known Samsung-specific issue: native debugging doesn't work because 
they made platform customizations without updating the run-as source 
appropriately. The problem is that "run-as" is looking for for 
/data/system/packages.list, which doesn't exist on the Samsung builds, 
because they use /dbdata instead of /data 

One solution is to root your system, then create a symlink from 
/data/system/ to /dbdata/system/. There is a previous post on the 
android-ndk forum about this. 

The same issue happens on Galaxy S builds, btw. 

 
Posted by 삼스
기타/Sound technology2011. 3. 18. 09:59

음성인식 방법.


마이크로부터 음성을 샘플링 하였다면 어떻게 음성인식을 수행하는 걸까...

일단 ADC를 하였다면 샘플링은 끝난것이다.
음성인식을 위해서는 이제 특징벡터를 추출하고 인식어휘를 훈련하는 과정이 필요하다. 이 때 사용되는 알고리즘은 크게 HMM, DTW, NNet등이 있고 음성인식의 특징벡터는 MFCC, LPCC가 있는데 MFCC가 더 많이 쓰인다.

이 알고리즘을 통해 인식어휘를 훈련하여 특징벡터를 얻은 후 이제 마이크로 입력된 음성으로부터 동일방식으로 특징벡터를 얻어서 두 데이터를 비교하여 가장 근접한 대상어휘를 인식결과로 출력하면 된다.

여기서 중요한것은 바로 이 인식어휘를 확보하여 DB로 구축하는것이다.

자신의 음성을 인식하고자 한다면 자신의 음성으로 특징벡터를 구하여 DB를 구축하면 된다.
여러사람의 음성을 인식하고자 한다면 여러사람의 음성으로 특징벡터를 구하여 DB를 구축하면 된다.

참고서적 
  Multimedia Sound Programming : 영진출판사 한학용,하성옥,허강인공저
  음성언어정보처리 : 홍릉과학출판사 오영환저
 
Posted by 삼스
Android/App개발2011. 2. 22. 21:42

안드로이드 윈도우용 adb 분석 - 2


open_src/system/core/adb가 윈도우용으로 빌드될 때 아래의 소스들이 컴파일된다.
 usb_windows.c
 get_my_path_windows.c
 adb.c 
 console.c 
 transport.c 
 transport_local.c 
 transport_usb.c 
 commandline.c 
 adb_client.c 
 sockets.c 
 services.c 
 file_sync_client.c 
 shlist.c 
 utils.c 
 usb_vendors.c

아래 위치의 헤더파일들이 참조된다.
development/host/windows/usb/api/

프로그램의 시작지점은 아래와 같다.

int main(int argc, char **argv)
{
    adb_trace_init();
#if ADB_HOST
    adb_sysdeps_init();
    return adb_commandline(argc - 1, argv + 1);
#else
    if((argc > 1) && (!strcmp(argv[1],"recovery"))) {
        adb_device_banner = "recovery";
        recovery_mode = 1;
    }

    start_device_log();
    return adb_main(0);
#endif
}

commandline.c의 아래 함수에 커맨드라인 명령어의 처리 코드를 찾아볼 수 있다.

int adb_commandline(int argc, char **argv)
{
...
}

Posted by 삼스
Android/App개발2011. 2. 22. 21:15

안드로이드 윈도우용 adb 분석 - 1


adb윈도우용은 AdbWinApi.dll과 AdbWinUsbApi.dll과 함께 연동된다.
주요 API는 AdbWinApi.dll에 정의되어 있으며 AdbWinUsbApi.dll은 실제 Usb device와 연동부분을 책임진다.

오픈소스상의 아래 위치에 소스가 위치한다.

open_src/system/core/adb -> adb server, adb demon, adb client based on command-line의 소스가 OS별(linux, window, OSX)로 구현되어 있다.
open_src/developments/hosts/windows/usb -> 윈도우용 AdbWinApi.dll과 AdbWinUsbApi.dll의 소스와 드라이버등이 있다.

developments/hosts/windows/usb폴더구조는 다음과 같다.
 adb_winapi_test : test app
 api                   : AdbWinApi의 소스, adb.exe가 직접적으로 사용한다.
 legacy              : 드라이버
 winusb             : AdbWinUsbApi의 소스, Usb 연동부분에 대한 소스로 AdbWinApi가 로드하여 사용한다.

adb와 유사한 클라이언트 앱을 만들고자 한다면 AdbWinApi.dll이 노출하는 API들에 대한 스펙을 숙지하는것이 중요하다.
아래에 몇가지 API들을 소개한다.

adb_api.h
ADBWIN_API ADBAPIHANDLE __cdecl AdbEnumInterfaces(GUID class_id,
                                          bool exclude_not_present,
                                          bool exclude_removed,
                                          bool active_only);

ADBWIN_API bool __cdecl AdbNextInterface(ADBAPIHANDLE adb_handle,
                                 AdbInterfaceInfo* info,
                                 unsigned long* size);

ADBWIN_API bool __cdecl AdbResetInterfaceEnum(ADBAPIHANDLE adb_handle);

ADBWIN_API ADBAPIHANDLE __cdecl AdbCreateInterfaceByName(const wchar_t* interface_name);

ADBWIN_API ADBAPIHANDLE __cdecl AdbCreateInterface(GUID class_id,
                                           unsigned short vendor_id,
                                           unsigned short product_id,
                                           unsigned char interface_id);

ADBWIN_API bool __cdecl AdbGetInterfaceName(ADBAPIHANDLE adb_interface,
                                    void* buffer,
                                    unsigned long* buffer_char_size,
                                    bool ansi);

ADBWIN_API bool __cdecl AdbGetSerialNumber(ADBAPIHANDLE adb_interface,
                                   void* buffer,
                                   unsigned long* buffer_char_size,
                                   bool ansi);

ADBWIN_API bool __cdecl AdbGetUsbDeviceDescriptor(ADBAPIHANDLE adb_interface,
                                          USB_DEVICE_DESCRIPTOR* desc);

ADBWIN_API bool __cdecl AdbGetUsbConfigurationDescriptor(
                    ADBAPIHANDLE adb_interface,
                    USB_CONFIGURATION_DESCRIPTOR* desc);

ADBWIN_API bool __cdecl AdbGetUsbInterfaceDescriptor(ADBAPIHANDLE adb_interface,
                                             USB_INTERFACE_DESCRIPTOR* desc);

ADBWIN_API bool __cdecl AdbGetEndpointInformation(ADBAPIHANDLE adb_interface,
                                          unsigned char endpoint_index,
                                          AdbEndpointInformation* info);

ADBWIN_API bool __cdecl AdbGetDefaultBulkReadEndpointInformation(
                    ADBAPIHANDLE adb_interface,
                    AdbEndpointInformation* info);

ADBWIN_API bool __cdecl AdbGetDefaultBulkWriteEndpointInformation(
                    ADBAPIHANDLE adb_interface,
                    AdbEndpointInformation* info);

ADBWIN_API ADBAPIHANDLE __cdecl AdbOpenEndpoint(ADBAPIHANDLE adb_interface,
                                        unsigned char endpoint_index,
                                        AdbOpenAccessType access_type,
                                        AdbOpenSharingMode sharing_mode);

ADBWIN_API ADBAPIHANDLE __cdecl AdbOpenDefaultBulkReadEndpoint(
                            ADBAPIHANDLE adb_interface,
                            AdbOpenAccessType access_type,
                            AdbOpenSharingMode sharing_mode);

ADBWIN_API ADBAPIHANDLE __cdecl AdbOpenDefaultBulkWriteEndpoint(
                            ADBAPIHANDLE adb_interface,
                            AdbOpenAccessType access_type,
                            AdbOpenSharingMode sharing_mode);

ADBWIN_API ADBAPIHANDLE __cdecl AdbGetEndpointInterface(ADBAPIHANDLE adb_endpoint);

ADBWIN_API bool __cdecl AdbQueryInformationEndpoint(ADBAPIHANDLE adb_endpoint,
                                            AdbEndpointInformation* info);

ADBWIN_API ADBAPIHANDLE __cdecl AdbReadEndpointAsync(ADBAPIHANDLE adb_endpoint,
                                             void* buffer,
                                             unsigned long bytes_to_read,
                                             unsigned long* bytes_read,
                                             unsigned long time_out,
                                             HANDLE event_handle);

ADBWIN_API ADBAPIHANDLE __cdecl AdbWriteEndpointAsync(ADBAPIHANDLE adb_endpoint,
                                              void* buffer,
                                              unsigned long bytes_to_write,
                                              unsigned long* bytes_written,
                                              unsigned long time_out,
                                              HANDLE event_handle);

ADBWIN_API bool __cdecl AdbReadEndpointSync(ADBAPIHANDLE adb_endpoint,
                                    void* buffer,
                                    unsigned long bytes_to_read,
                                    unsigned long* bytes_read,
                                    unsigned long time_out);

ADBWIN_API bool __cdecl AdbWriteEndpointSync(ADBAPIHANDLE adb_endpoint,
                                     void* buffer,
                                     unsigned long bytes_to_write,
                                     unsigned long* bytes_written,
                                     unsigned long time_out);

ADBWIN_API bool __cdecl AdbGetOvelappedIoResult(ADBAPIHANDLE adb_io_completion,
                                        LPOVERLAPPED overlapped,
                                        unsigned long* bytes_transferred,
                                        bool wait);

ADBWIN_API bool __cdecl AdbHasOvelappedIoComplated(ADBAPIHANDLE adb_io_completion);


ADBWIN_API bool __cdecl AdbCloseHandle(ADBAPIHANDLE adb_handle);

Posted by 삼스
Android/App개발2011. 2. 11. 17:39

Maven환경에서 안드로이드 어플 개발하기


원문 : http://www.wakaleo.com/blog/302-android-development-with-maven

당신이 자바개발자고 모바일디바이스용 앱을 작성하고자 한다면 안드로이드는 의심할 여지 없는 최적의 플랫폼이다. 당신이 알고있는 자바기술과 툴등 이미 익숙한 환경에서 접근이 가능하다. 이런 이유로 iPhone이나 iPad용 앱개발보다 접근이 쉽다. 또한 훌룡한 많은 툴들과 기술들을 사용할 수 있다(유닛테스트, 자동빌드, 연속빌드등등)

이 문서는 안드로이드 앱개발에 관한것이 아니다. 자동화된 빌드인프라에 안드로이드프로세스를 통합하는것에 대한 내용을 기술한다. 두개의 시리즈로 나뉘며 첫번째는 안드로이드 빌드프로세스를 메이븐을 통해 자동화하는 법에 대한 내용이고 두번째는 자동화된 테스트와 연속빌드에 대한 내용이다.

안드로이드 개발자는 이클립스를 많이 사용한다. 안드로이드는 훌룡한 이클립스플러그인을 제공하는데 안드로이드개발관련 많은 항목들을 아주 쉽게 사용할 수 있게 해준다. 실시간 안드로이드의 에러체킹과 빌드와 에뮬레이터와 연결하여 테스트하는것까지 가능하다.

그러나 멋진 이클립스플러그인도 빌드프로세스를 자동화하지는 못하고 있고 많은 메이븐의 기능들이 빠져있다(의존성을 선언만으로 관리하는것과 배포프로세스를 클린하는것). 다행히 메이븐플러그인이 존재한다. 다만 이 두가지를 잘 사용하려면 조심해서 써야 한다. 이 문서에서 안드로이드에서 메이븐을 다루는 기본적인 사항에 대한것과 몇가지 팁 그리고 방법에 대해 안내할것이다.

시작하기
먼저 안드로이드 SDK와 이클립스플러그인이 설치되었음을 가정한다. 설치가 안되었다면 먼저 설치후 진행하기 바란다. 정상적으로 환경이 갖추어졌다면 File->New->Android Project를 선택하면 아래 화면이 나타날것이다.

Android and Maven
이클립스는 좋지만 중요한 자바개발프로젝트는 하나의 자동화된 빌드스크립트가 필요하다. 안드로이드가 메이븐과 함께 작업되게 하려면 몇가지 단계의 작업을 해야 한다. 먼저 ANDROID_HOME환경변수를 안드로이드SDK가 설치된 경로로 설정한다.
export ANDROID_HOME=/opt/android-sdk-linux
메이븐 안드로이드 플러그인은 이 환경변수가 필요하다.
또한 settings.xml파일에 안드로이드 플로그인 그룹을 반드시 추가해야 한다. 그러면 커맨드라인에서 안드로이드플러그인을 쉽게 사용할 수 있다.
<pluginGroups>
  <pluginGroup>com.jayway.maven.plugins.android.generation2</pluginGroup> 
</pluginGroups>
안드로이드 AVD Manager에서 emulator를 생성하라. 여기서 입력한 AVD name은 프로젝트설정파일(pom.xml)에서 참조된다.
이제 당신의 프로젝트에서 pom.xml파일을 편집할 차례이다. 간편한 방법은 프로젝트 디렉토리에서 바로 pom.xml파일을 생성하는 것이다. pom.xml파일의 예제를 아래 나타내었다.
<project xmlns="http://maven.apache.org/POM/4.0.0" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.wakaleo.training.android.qotd</groupId>
  <artifactId>QuoteOfTheDay</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>apk</packaging>
  <name>QuoteOfTheDay</name>
  <dependencies>
    <dependency>
      <groupId>com.google.android</groupId>
      <artifactId>android</artifactId>
      <version>2.2.1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>com.google.android</groupId>
      <artifactId>android-test</artifactId>
      <version>2.2.1</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.8.2</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.hamcrest</groupId>
      <artifactId>hamcrest-all</artifactId>
      <version>1.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-all</artifactId>
      <version>1.8.5</version>
      <scope>test</scope>
    </dependency>

  </dependencies>
  <build>
    <sourceDirectory>src</sourceDirectory>
    <testSourceDirectory>test</testSourceDirectory>
    <plugins>
      <plugin>
        <groupId>com.jayway.maven.plugins.android.generation2</groupId>
        <artifactId>maven-android-plugin</artifactId>
        <version>2.6.0</version>
        <configuration>
          <sdk>
            <platform>8</platform>
          </sdk>
          <emulator>
            <avd>em22</avd>
          </emulator>
          <deleteConflictingFiles>true</deleteConflictingFiles>
          <undeployBeforeDeploy>true</undeployBeforeDeploy>
        </configuration>
        <extensions>true</extensions>
      </plugin>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
      </plugin>
    </plugins>
  </build>
</project>

위 pom.xml에서 중요한 항목이 두가지가 있다. 먼저 packaging타입이 apk인것이다. 이것은 안드로이드애플리케이션임을 나타낸다. dependencies에서 android와 android-test library는 provided로 설정되어 있다. 이 라이브러리는 디바이스에 존재하기 때문에 package에 포함되지 않도록 하게된다. 그리고 default source directory와 test directory를 를 변경하여 안드로이드 이클립스프로젝트 설정과 함께 사용가능해졌다.

이 pom파일은 메이블을 통해 커맨드라인명령으로 안드로이드의 공통된 작업을 할 수 있게 해준다. 예를 들어 애플리케이션을 빌드하는것이 단순해진다. 그냥 mvn clean install을 실행하면 된다. emulator에 deploy하고자 한다면 에뮬레이터를 먼저 띄워야 한다. 커맨드라인에서 띄우려면 mvn android:emulator-start를 실행하면 된다. 에뮬레이터는 1~2분 정도후에 뜨게 된다.
$ mvn android:emulator-start
[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] ------------------------------------------------------------------------
[INFO] Building QuoteOfTheDay 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] 
[INFO] --- maven-android-plugin:2.6.0:emulator-start (default-cli) @ qotd ---
[INFO] Android emulator command: /opt/android/android-sdk-mac_x86/tools/emulator -avd em22 
unknown
[INFO] Starting android emulator with script: /var/folders/y+/y+a+wZ-jG6WKHEm9KwnSvE+++TI/-
Tmp-//maven-android-plugin-emulator-start.sh
[INFO] Waiting for emulator start:5000
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 6.836s
[INFO] Finished at: Thu Oct 28 14:34:40 NZDT 2010
[INFO] Final Memory: 8M/81M
[INFO] ------------------------------------------------------------------------

그리고 에뮬레이터에 애플리케이션을 deploy하고 싶다면 mvn android:deploy를 실행하면 된다.
$ mvn android:deploy
[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] ------------------------------------------------------------------------
[INFO] Building QuoteOfTheDay 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] 
[INFO] --- maven-android-plugin:2.6.0:deploy (default-cli) @ qotd ---
[INFO] /opt/android/android-sdk-mac_x86/tools/adb [install, -r, /Users/johnsmart/Projects
/Training/android/android-quote-of-the-day/quoteoftheday/target/qotd-0.0.1-SNAPSHOT.apk]
[INFO] 1068 KB/s (13169 bytes in 0.012s)
        pkg: /data/local/tmp/qotd-0.0.1-SNAPSHOT.apk
Success
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 8.537s
[INFO] Finished at: Thu Oct 28 14:35:25 NZDT 2010
[INFO] Final Memory: 8M/81M
[INFO] ------------------------------------------------------------------------

이클립스로 돌아가서
이제 메이븐으로 당신을 안드로이드 앱을 빌드하고 배치할수 있게 되었다. 당신은 이제 이클립스를 이 파티에 초대할 필요가 있다. 프로젝트에 메이븐 기능을 활성화하는 일반적인 방법은 'Maven -> Enable Dependency Management'메뉴를 통해 가능하다. 불행히도 이작업이 불가능할것이다. 이작업을 하려면 m2eclipse Android Integration plugin 를 설치해야 한다. 이 플러그인은 m2eclipse와 Android Eclipse plugin를 연결해주는 역할을 한다. 이 플러그인을 설치하면 'Enable Dependency Management'메뉴가 나타날것이다.
메이븐이 활성화된 안드로이드 프로젝트를 'Run As-> Android Application'메뉴를 통해 실행이 가능해야 한다. 이는 에뮬레이터를 실행하고 애플리케이션을 배치할것이다. 또는 활성화된 애뮬레이터에 바로 배치할것이다.

이제 빌드하고, 배치하고 실행하는 것을 메이븐을 통한것과 이클립스를 통해 모두 가능해졌다. 이제 자동화된 빌드를 위한 문이 열렸다. 그리고 로컬 CI server를 셋업할수 있게 되었다.

다음 시리즈에서는 자동화된 유닌과 테스트를 통합하는것과 허드슨을 사용하여 당신의 안드로이드 프로젝트에 Continuous Integration을 셋업하는 방법에 대해 안내할것이다. 

Trouble shooting...
메이븐을 사용하는 가장 큰 이유는 참조라이브러리들의 관리가 쉽다는 것인데 위 절차대로 수행 후 센트럴레포지트리가 아닌 로컬레포지트리의 라이브러리를 가져오지 못하는 경우가 있을 수 있다.
콘솔에서는 참조를 잘하는데 이클립스에서는 잘 안된다면 바로 메이븐의 설정파일을 이클립스에서 참조하지 않고 있어서 발생하는것으로 생각하면 된다. 이것때문에 하루정도 삽질을 ...

eclipse 환경설정에서 Maven -> Installations에서 Add선택 후 설치한 메이븐 폴더를 지정해주면 된다.


Posted by 삼스
카테고리 없음2011. 2. 10. 14:20

OMA DRM


디지털컨텐츠의 저작권을 보호하기 위한 방안으로 DRM이 있는데 리를 OMA(Open Mobile Alliance)에서 모바일기기에 맞는 DRM 스텍을 정한것이  OMA DRM이다. 버전 1.0과 2.0이 있다.

SKT melon, KTF dosirak등이 모두 OMA DRM이 걸려 있다.

OMA DRM v1.0 에서 콘텐츠를 보호하는 3가지 수단을 제공한다.
1. Forward Lock
  다른장치로 이동할 수 없게 하는 방법을 제공한다. 사용이 허가된자만이 사용할 수있으므로 저작권보호가 이루어진다.
2. Combined Delivery
  컨텐츠에 대한 권리정보가 추가되어 횟수제와 기간제의 제한사항을 가할 수 있다. 이 방법도 Forward Lock과 마찬가지로 다른장치로 이동할 수 없다.
3. Seperate Delivery
  컨텐츠와 권리정보가 분리되어 따로따로 암호화 되어 있다. 따라서 다른장치로 이동이 가능하고 권리정보도 함께 이동하여 컨텐츠의 이용이 가능하다. seperate delivery가 필요한 이유는 combined delivery의 경우 제한사항이 만료되면 새로 컨텐츠를 다운받아야 하지만 serperate delivery는 권리정보만 새로 받으면 되기 때문에 사용성에서 유리하다.

OMA DRM v2.0은 아래의 추가적인 수단을 제공한다.
1. Domain
2. Backup
3. Super Distribution
4. Export
5. Unconnected Device Support
6. Basic Pull Model
7. Push of DRM Content
8. Streaming of DRM Content


참고블로그
http://kscho.tistory.com/entry/OMA-DRM

Posted by 삼스
Android/App개발2011. 1. 6. 13:36

자바 쓰레드의 resume, suspend, stop 구현

펌출처 : http://javafreak.tistory.com/232#comment4925306


자바 언어가 1.x 에서 2.x 대를 넘나들 시절에 thread 를 다룰때 뻔질나게 자주 쓰였던 thread 메소드가 resume, suspend , stop 인데 아쉽게도 deprecated (앞으로 쓰지 말라는 뜻) 되어서 별 수 없이 쓰레드의 상태를 관리하는 방식으로 구현을 해야 한다.

구현은 아래와 같은 간단한 코드에서 시작한다.
public class ThreadHandle implements Runnable {
    @Override    public void run() {
        // TODO Auto-generated method stub
    }
}
Runnable을 구현한 것을 볼 수 있는데, 꼭 저렇게 할 필요는 없으나 Runnable을 implement 해주지 않으면 별도의 구현체를 클래스로 정의해야하기 때문에 쓰레드를 이용해서 단위 작업을 수행하는 ThreadHandle과 같은 클래스가 자체적으로 Runnable을 구현하면 편리하다.

이제 저 상태에서 start, resume, suspend, stop 메소드를 정의해준다.
public class ThreadHandle implements Runnable {
    public void start(){
        ;
    }
    public void resume() {
        ;
    }
    public void suspend() {
        ;
    }
    public void stop() {
        ;
    }
    public void join() {
        ;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
    }
}
ThreadHandle을 사용하는 쪽에서는 아래와같이 초기화하는데 쓰레드를 사용하는 것과 별 차이가 없어보이게 된다.
    public void test_thread_handle() throws Exception {
        ThreadHandle threadHandle = new ThreadHandle();
        threadHandle.start();
    }
그리고 start() 메소드가 제대로 동작하도록 하려면 아래와 같이 ThreadHandle이 thread를 생성하고 실행하게 만들어준다.
    private Thread thisThread ;
    private String threadName ;
    public ThreadHandle(){}
    public ThreadHandle(String threadName){
        this.threadName = threadName;
    }
    public void start(){
        thisThread = new Thread(this);
        if ( threadName != null) thisThread.setName(threadName);
        thisThread.start();
    }
ThreadHandle.start() 안에서 쓰레드 인스턴스를 생성하고 start()를 호출함으로써 새로운 쓰레드가 실행된다. threadHandle.start()를 호출이 <<main>> 쓰레드에서 실행되었다면 아래와 같이 새로운 쓰레드가 분기하게 된다.

두 개의 쓰레드가 함께 실행된다.

"t-0"라고 이름을 붙인 새로운 쓰레드는 run() 메소드를 시작으로 작업을 수행하는데 쓰레드에 일시정지, 재시작, 종료 기능을 추가하기 위해서 run() 메소드 안에서 반복문을 집어넣는다.
public class ThreadHandle implements Runnable {
    ....
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while ( true ){
            processTask();
        }
    }
}
반복문에 별다른 종료 조건을 주지 않았기 때문에 위와같은 상태에서는 정신없이 작업이 계속될 것이다. while 안에 적절한 종료 조건을 넣어서 적절한 시점에 쓰레드가 종료하게 해야 한다.

종료 조건은 두가지로 나눌 수 있다.

1. run() 메소드의 반복문 안에서 더이상 작업을 계속할 필요가 없어서 끝내는 경우
2. 외부에서 ThreadHandler.stop() 메소드를 호출했을 때.

1번은 쓰레드가 스스로 종료 조건을 판단하는 것이고 2번은 외부에서 강제로 종료시키는 경우에 해당한다.

1번의 전형적인 예로 소켓 연결을 통해서 데이터를 주고받은 뒤 연결을 끊는 경우를 들 수 있다.
    public void run() {
        while ( true ) {
            int nRead = in.read(buf, 0, buf.length);
            if ( nRead < 0 ) break;
            ....
        }
    }
더이상 읽을 데이터가 없다면 while 문을 끝내고 run() 메소드가 종료하면서 쓰레드도 생을 마감하게 된다.

2번처럼 외부에서 강제로 종료시키는 경우(정확하게 말하면 종료하라고 신호만 보낸다. 자바 스레드에서는 한 스레드가 다른 스레드를 강제로 종료시킬 방법이 없다.)가 바로 여기서 구현할 내용인데 다음과 같이 thread의 상태를 나타내는 static 변수를 정의하고 이를 참조하는 stateCode 프로퍼티를 도입해서 상태를 관리한다.
public class ThreadHandle implements Runnable {
    final private static int STATE_INIT = 0x1;
    final private static int STATE_STARTED = 0x1 << 1;
    final private static int STATE_SUSPENDED = 0x1 << 2;
    final private static int STATE_STOPPED = 0x1 << 3;

    private int stateCode = STATE_INIT;
    public void start(){
        if ( stateCode != STATE_INIT) // INIT 상태가 아니면 이미 실행되었다.
            throw new IllegalStateException("already started");
        
        thisThread = new Thread(this);
        if ( threadName != null) thisThread.setName(threadName);
        thisThread.start();
        stateCode = STATE_STARTED;
    }
    ....
    public void stop() {
        if ( stateCode == STATE_STOPPED) // 이미 멈췄다면 또 호출할 필요가 없음.
            throw new IllegalStateException("already stopped");
        thisThread.interrupt();
        stateCode = STATE_STOPPED ;
    }
    ....
}
STATE_INIT은 쓰레드 인스턴스가 생성되었지만 실행되지는 않은 상태를 의미하고, STATE_STARTED 는 Thread의 start() 메소드가 호출되어서 실행된 상태를 의미한다. 마찬가지로 STATE_STOPPED 는 쓰레드가 끝났거나 끝나는 중임을(while 루프를 빠져나와서 run() 메소드가 끝나가는 단계) 나타낸다.

각 상태는 다음 상태의 조건이 되는데, start() 메소드에서 현재 상태를 확인해서 STATE_INIT이 아니라면 이미 시작되었다는 뜻이므로 예외를 던지게 한다. 마찬가지로 stop() 메소드에서도 상태가 STATE_STOPPED 라면 이미 종료가 되었거나 종료 중이므로 예외를 던진다.

위 구현은 멀티쓰레드 환경에서는 오작동을 할 가능성이 있는데, 하나의 ThreadHandle 인스턴스를 여러개의 스레드들이 공유하는 상황이라면 스레드들이 동시에 start(), stop() 메소드를 호출할 때 stateCode 프로퍼티의 일관성이 깨질 수가 있다.

스레드 A와 스레드 B가 동시에 start()를 호출할 때 A가 현재 stateCode가 STATE_INIT임을 보고 if 조건절을 무사히 통과해서 thisThread.start();를 호출할 것이다. 그리고 스레드 A가 stateCode를 STATE_STARTED로 갱신하기 전에 스레드 B가 if 조건절에 진입하면 stateCode가 STATE_INIT 이기 때문에 무사히 통과해서 또다시 스레드 인스턴스를 생성하고 실행시키게 된다.

스레드 A가 stateCode를 갱신한 후에 스레드 B가 if 조건절에 진입하더라도 stateCode가 volatile이 아니기 때문에 스레드 B는 스레드 A가 갱신한 최신의 stateCode 값을 보지 못할 수도 있다.

따라서 ThreadHandle을 멀티쓰레드에서 안전하게 하려면 아래와 같이 critical section을 잘 막아줘야 한다.
    public void start(){
        synchronized ( this ){
            if ( stateCode != STATE_INIT)
                throw new IllegalStateException("already started");
            
            thisThread = new Thread(this);
            if ( threadName != null) thisThread.setName(threadName);
            thisThread.start();
            stateCode = STATE_STARTED;
        }
    }
    ....
    public void stop() {
        synchronized ( this ){
            if ( stateCode == STATE_STOPPED)
                throw new IllegalStateException("already stopped");
            this.stateCode = STATE_STOPPED;
            thisThread.interrupt();
        }
    }
suspend(), resume() 도 위와같이 구현하면 오직 하나의 스레드만이 threadHandle의 상태를 변경할 수 있고 상태를 변경하는동안 다른 스레드들이 진입해서 일관성이 깨지는 것을 막을 수 있다.

stop() 메소드가 호출된 후 상태가 변경되었으므로(stateCode가 변경되었으므로) run() 메소드의 while 문 안에서 이 변경을 확인해서 반복문을 빠져나오는 코드를 삽입한다.
    @Override
    public void run() {
        while ( true ){            
            if ( stateCode == STATE_STOPPED)
                break; //종료하라는 신호이므로 루프를 끝낸다.
            processComplexJob();
        }
    }
위에서는 processComplexJob(); 메소드를 실행하기 전에 상태를 확인했는데, 수행할 작업을 끝내는데 꽤 많은 시간이 걸린다면 그 작업을 시작하기 전에 확인해주면 응답성을 높일 수가 있다. 

하지만 if 조건절을 판단한 직후에(종료조건이 아님을 확인한 직후에) 다른 스레드가 stop() 을 호출해서 스레드의 상태를 STATE_STOPPED로 바꾸주었다면 간발의 차이로 오랜 시간이 걸리는 작업은 실행될 수 밖에 없다.

이럴 경우 processComplexJob() 메소드 안에서 별도로 stateCode를 다시 한 번 확인하지 않는 한, 일단 시작된 작업이 끝나고 나서 while문을 한 번 반복한 후 다시 if 조건절에 도착해서 STAE_STOPPED 값을 보고 루프를 빠져나올 것이다.

suspend()를 구현한 코드는 아래와 같은데 stateCode 값을 변경하기 전에 현재의 상태를 미리 확인하는 과정을 거친다.
    public void suspend() {
        synchronized ( this ){
            if ( stateCode == STATE_SUSPENDED) return;
            if ( stateCode == STATE_INIT )
                throw new IllegalStateException("not started yet");
            if ( stateCode == STATE_STOPPED)
                throw new IllegalStateException("already stopped");
            stateCode = STATE_SUSPENDED;
        }    
    }
현재의 상태가 STATE_STARTED 가 아니라면 일시 정지가 별 의미가 없으므로 위처럼 모든 상태를 체크해서 적절히 예외를 던지거나 더이상 진행하지 말아야 하는데, 모든 상태를 체크하다보니 실제 상태를 변경하는 코드보다 조건을 검증하는 코드(if 구문들)가 더 많아진다. 

여기서는 STARTED, SUSPENDED, STOPPED 의 조건만을 판단하기 때문에 코딩량을 감당할 수 있으나 구현 조건에 따라서 정지중, 정지, 종료중, 종료, 재시작중, 재시작처럼 쓰레드가 거치는 상태가 많다면 state pattern을 도입하는 것을 고려해볼만 하다. 

일시 정지 기능을 구현했으니 stateCode의 변경을 보고 스레드를 잠시 정지하는 기능을 run 메소드의 while 반복문 안에 삽입해준다.
    public void run() {
        while ( true ){
            // 상태 코드가 일시 정지라면 while문에서 계속 대기하도록 한다.
            while ( stateCode == STATE_SUSPENDED){
                try {
                    System.out.println("[handle] suspending...");
                    Thread.sleep(24 * 60 * 60 * 1000);
                } catch (InterruptedException e) {
                    if ( stateCode != STATE_SUSPENDED){
                        System.out.println("[handle] resuming...");
                        break;
                    }
                }
            }
            if ( stateCode == STATE_STOPPED){
                System.out.println("[handle] stopping...");
                break;
            }
            processComplexJob();
        }
여기서는 아주 오랜시간동안 쓰레드를 재우는 식으로 구현했는데 저렇게 오랫동안 스레드를 정지시켰을때에는 반드시 누군가가 thisThread.interrupt(); 를 호출해주어야 한다. 따라서 suspend()에서 잠재운 스레드를 다시 실행시키는 resume() 메소드에서는 반드시 thisThread.interrupt(); 를 호출해 준다.
    public void resume() {
        synchronized ( this ){
            if ( stateCode == STATE_STARTED || stateCode == STATE_INIT) return;
            if ( stateCode == STATE_STOPPED)
                throw new IllegalStateException("already stopped");
            stateCode = STATE_STARTED;
            thisThread.interrupt(); // 꼭 해줘야 한다.
        }
    }
stop() 메소드 구현에서도 interrupte() 를 호출하는데, stop() 메소드는 이미 멈춘 상태가 아니라면 언제든 호출될 수 있기 때문에 resume()과 마찬가지로 상태를 변경한 후에 스레드를 깨워주어야 한다. 

마지막으로 stateCode 를 volatile 로 바꿔주어서 run() 메소드를 실행중인 스레드가 공유 변수의 복사본만 바라보느라 외부 스레드가 갱신한 최신의 stateCode 의 값을 놓치는 일이 없게 해준다.
public class ThreadHandle implements Runnable {
    ....
    private volatile int stateCode = STATE_INIT;
이렇게 대강 start, resume, suspend, stop 기능을 구현했는데, 이런 메소드가 호출될때마다 ThreadHandle 내에서 관리하는 스레드는 아래와 같이 상태 전이가 반복된다.
스레드의 상태 전이를 관리할 때 위와같이 state diagram을 그려놓으면 구현할 때 도움이 많이 된다.  현재 상태에 따라서 호출할 수 있는 메소드의 종류가 나뉘는 것을 한눈에 알 수 있기 때문에 상태 관리 및 전이를 코드로 옮기기에 용이하다.

어떤 코드들을 보면 스레드에 걸리는 인터럽트 신호를 상태 전이의 조건으로 사용하는 경우도 있다. 

위에서는 stop()이 호출된 후 run() 메소드의 while 문 안에서 STATE_STOPPED 값을 확인하고 break; 하도록 했는데 아래처럼 while문의 조건절에서 인터럽트 신호 여부를 종료 조건으로 판단할 수도 있다.
    while ( ! thisThread.isInterrupted() ){
        .....
    }
이럴 경우 스레드 내에서 함부로 인터럽트 신호를 먹어버리지 않도록 유의해야한다. ( 관련글 : [Java] 자바 Thread의 interrupt 이해하기 ) 실행 상태가 아닌 BLOCK 상태에서 인터럽트를 걸면 스레드가 깨어나면서 인터럽트 신호가 해제되므로 catch 절에서 다시 한 번 인터럽트를 걸어서 인터럽스 신호를 복구시켜야 한다.
    try {
        Thread.sleep( sleepTime );
    catch (InteruptedException e){
        thisThread.interrupt(); // 다시 한 번 신호를 걸어준다.
    }
인터럽트 신호를 상태 전이의 힌트로 사용하는 방식도 나쁘진 않지만 스레드가 java nio 를 이용해서 스트립 입출력을 다룬다면 스레드에 인터럽트를 걸 때 신중해야 한다.

NIO 이전의 입출력 메소드들은 읽기, 쓰기 도중에 BLOCK 상태에 있으면 인터럽트에도 반응하지 않았지만 NIO 에서는 읽고 쓰는 도중에 BLOCK 상태에 있을때 인터럽트를 걸면 ClosedByInterruptException 예외가 던져지면서 스트림이 닫혀버린다. ( BLOCK 상태가 아니더라도 현재 스레드에 인터럽트가 걸려있는걸 확인하면 NIO 관련 스트림 클래스들은 스트림을 닫아버린다.)

위의 구현에는 해당되지 않으나 단지 스레드를 깨울 목적으로 인터럽트를 걸었는데 NIO 의 read() 에서 여전히 살아있는 인터럽트 신호를 보고 스트림을 닫아버리는 일이 발생한다. 이럴 경우 NIO의 read, write 실행 직전에 반드시 인터럽트 신호를 해제해줘야하고 read, write 실행 중에 인터럽트가 걸리지 않게 해줘야 하는데 이렇게되면 "입출력중" 이라는 별도의 상태를 정의해야 할 수도 있다. ( 복잡도 증가 )

Posted by 삼스

티스토리툴바