개발여행기

getMainLooper() 함수 

getMainLooper() 함수는 Main Thread(UI Thread)가 사용하는 Looper 즉 Main Looper를 반환합니다.

이 함수는 호출하는 스레드가 메인 스레드이거나 메인 스레드가 아니어도 언제든지 Main Looper를 반환합니다.

참고 1) Main thread의 Main Looper와 Handler는 ActivityThread에서 자동으로 생성하기 때문에 개발자가 명시적으로 생성하지 않습니다.

참고 2) Looper.myLooper() 함수는 호출한 스레드의 Looper를 반환합니다.

getMainLooper() 함수는 어떤 경우에 사용하면 될까요?

크게 3가지의 경우에 사용합니다.

1. Handler를 생성할 때 Main Looper를 생성자의 인자로 전달하고 싶을 경우

즉, 작업자 스레드(UI thread가 아닌 스레드)에서 UI thread에게 "Runnabel 작업" 또는 "메시지"을 보내고 싶을 때 사용할 수 있는 방법입니다.

View.post() 또는 runOnUiThread() API를 사용하는 것도 작업자 스레드에서 UI thread로 Runnable객체를 전달하는 용도로 사용됩니다.

public class MainActivity extends AppCompatActivity {
    private String TAG = "MainActivity";
    private TestThread mTestThread;
    private Button mButton;
    static int count = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mButton = (Button)findViewById(R.id.button);
    }

    public void onClickButton(View view) {
        Log.d(TAG, "onClickButton");

        mTestThread = new TestThread();
        mTestThread.start();
    }

    class TestThread extends Thread {
        private Handler mHandler;

        TestThread() {
            mHandler = new Handler(Looper.getMainLooper()) {  // 핸들러에 Main Looper를 인자로 전달
                @Override
                public void handleMessage(Message msg) {  // 메인 스레드에서 호출
                    Log.d(TAG,"handleMessage : " + msg.what);

                    switch(msg.what) {
                        case 0:
                            mButton.setText("Button 0");
                            break;
                        case 1:
                            mButton.setText("Button 1");
                            break;
                        case 2:
                            mButton.setText("Button 2");
                            count = 0;
                            break;
                        default:
                            break;
                    }
                }
            };
        }

        @Override
        public void run() {
            Log.d(TAG, "Start TestThread");

            Message msg = mHandler.obtainMessage(count++);
            mHandler.sendMessage(msg);  // 메인 스레드로 메시지를 보냄
        }
    }
}

Handler를 생성할 때 인자로 Looper를 전달하면 어떤 과정을 거치는지 보도록 하겠습니다. (xref : Handler.java)

Main Looper를 인자로 넣으면 Main Looper의 Queue를 mQueue로 설정합니다. 이 부분이 중요합니다.

결론적으로 sendMessage() 또는 post()를 하게 되면 mQueue에 메시지나 작업이 들어가게됩니다. 즉 Main thread의 큐에 들어갑니다.

따라서 dequeue가 될때 Main thread에서 실행되는 것입니다.

실행 로그를 확인해 보겠습니다.

TestThread 스레드는(TID 12310) sendMessage() 함수를 호출하였고, 메인 스레드(TID 12235)에서 handleMessage() 함수가 호출되었습니다.

이 함수는 버튼을 터치할 때 전달 받은 msg.what 값에 setText("Button 0"), setText("Button 1"), setText("Button 2") 반복적으로 변경합니다. 

같은 원리로 다음 예제는 Runnable 작업을 메인 스레드로 전달하는 코드입니다.

public class MainActivity extends AppCompatActivity {
    private String TAG = "MainActivity";
    private TestThread mTestThread;
    private Button mButton;
    static int count = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mButton = (Button)findViewById(R.id.button);
    }

    public void onClickButton(View view) {
        Log.d(TAG, "onClickButton");

        mTestThread = new TestThread();
        mTestThread.start();
    }

    class TestThread extends Thread {

        @Override
        public void run() {
            Log.d(TAG, "Start TestThread");

            Handler handler = new Handler(Looper.getMainLooper());  // 핸들러에 메인 루퍼를 인자로 전달
            handler.post(new Runnable() {  // 메인 스레드로 Runnable 객체를 보냄, runOnUiThread()함수 사용과 유사

                @Override
                public void run() {  // run()함수는 메인 스레드에서 실행 됨
                    Log.d(TAG, "Change Button text");
                    mButton.setText("Button changed");
                }
            });
        }
    }
}

2. 현재 스레드의 루퍼가 Main Looper인지 아닌지 검사하고 싶을 경우

아래 예제에는 코드와 같이 버튼 UI 텍스트를 변경하는 changeButtonText() 함수가 있습니다.

이 함수를 호출하는 스레드의 Looper가 Main Looper 인지 아닌지에 따라서 버튼 UI 텍스트를 변경하는 방법을 다르게 하고 있습니다.

UI 변경은 UI thread에서만 허용하기 때문입니다.

만약 Main Looper라면 이것은 스레드가 Main 스레드를 의미하기 때문에 바로 setText() 함수를 호출 할 수 있습니다.

하지만 Main Looper가 아니라면 runOnUiThread() 또는 View.post() 함수 등을 사용해야 합니다.

public class MainActivity extends AppCompatActivity {
    private String TAG = "MainActivity";
    private TestThread mTestThread;
    private Button mButton;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mButton = (Button)findViewById(R.id.button);
    }

    public void onClickButton(View view) {
        Log.d(TAG, "onClickButton");
        changeButtonText();

        mTestThread = new TestThread();
        mTestThread.start();
    }

    class TestThread extends Thread {
        @Override
        public void run() {
            Log.d(TAG, "Start TestThread");
            changeButtonText();
        }
    }

    public void changeButtonText() {
        Log.d(TAG, "changeButtonText myLooper() " + Looper.myLooper());

        if (Looper.getMainLooper() == Looper.myLooper()) { // 현재 스레드의 루퍼와 메인 루퍼가 같은지 비교
            mButton.setText("Button 1");
            Log.d(TAG, "changeButtonText method is called from main thread");
        } else {
            (MainActivity.this).runOnUiThread(new Runnable() {

                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    mButton.setText("Button 2");
                    Log.d(TAG, "changeButtonText method is called from non-main thread");
                }
            });
        }
    }
}

실행 로그 입니다.

onClickButton에서 실행된 changeButtonText() 함수는 Main Looper를 사용하는 스레드에서 호출되었습니다.

그리고 별도로 생성한 스레드에서 호출된 changeButtonText() 함수는 당연히 Looper를 생성한 적이 없으므로 Looper.myLooper() 함수를 호출하면 null을 리턴합니다.

Looper.myLooper() 함수를 로그로 출력하였을 때 내용은 아래와 같습니다.

Looper (main, tid 1)   <== 메인 스레드에서 호출

null   <== TestThread에서 호출

이것이 의미하는 것을 알기 위해서 Looper 클래스의 toString()함수를 보도록 하겠습니다. (xref : Looper.java)

Looper (" 스레드 이름", "스레드 ID") 임을 알 수 있습니다.

3. 현재 스레드가 Main thread(UI thread)인지 아닌지 검사하고 싶을 경우

public class MainActivity extends AppCompatActivity {
    private String TAG = "MainActivity";
    private TestThread mTestThread;
    private Button mButton;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mButton = (Button)findViewById(R.id.button);
    }

    public void onClickButton(View view) {
        Log.d(TAG,"onClickButton()" + " " + Thread.currentThread() + " " + Looper.getMainLooper().getThread());

        if (Thread.currentThread() == Looper.getMainLooper().getThread()) {
            Log.d(TAG,"onClickButton() : This thread is main thread!");
        }
        else {
            Log.d(TAG,"onClickButton() : This thread is not main thread!");
        }

        mTestThread = new TestThread();
        mTestThread.start();
    }

    class TestThread extends Thread {
        @Override
        public void run() {
            Log.d(TAG,"TestThread run()" + " " + Thread.currentThread() + " " + Looper.getMainLooper().getThread());
            if (Thread.currentThread() == Looper.getMainLooper().getThread()) {
                Log.d(TAG,"TestThread run() : This thread is main thread!");
            }
            else {
                Log.d(TAG,"TestThread run() : This thread is not main thread!");
            }
            while(true) {  // ps 명령어로 스레드 ID를 보기 위해서 스레드가 종료되지 않도록 하기 위한 코드
                // 아무 동작도 안하고 그냥 살아 있는 스레드
            }
        }
    }
}

로그를 확인하기 전에 코드만으로 예측해보면 onClickButton() 함수는 UI thread에서 호출되기 때문에 "This thread is main thread!" 가 출력될 것이라는 것을 예측할 수 있습니다.

그리고 TestThread 스레드가 생성되어 run() 함수가 동작하는 스레드는 메인 스레드가 아닌 백그라운드 스레드입니다.

따라서 "This thread is not main thread!" 가 출력 될 것입니다.

실행 로그를 보도록 하겠습니다.

앞서 예측한 결과와 동일한 값이 출력 되었습니다.

ps 정보를 보면 아래와 같이 TestThread의 Name은 "Thread-175" 입니다.

Thread.currentThread()와 Looper.getMainLooper.getThread() 함수는 모두 Thread 클래스 객체를 반환합니다. 

출력 내용을 보면 아래와 같습니다.

Thread[main,5,main]   <== main thread

Thread[Thread-175,5,main]  <== TestThread

Thread 클래스 객체를 log로 출력했기 때문에 Thread 클래스의 toString() 함수가 호출되었습니다. 

Thread["현재 스레드 이름", "우선순위", "스레드 그룹"] 형식으로 출력됩니다.

main 스레드와 TestThread 스레드는 이름은 다르지만 우선순위와 스레드 그룹은 동일하게 출력되었습니다.

별도로 우선순위와 스레드 그룹을 설정하지 않았기 때문에 default 상태의 값이 설정되어 있습니다.

이상으로 getMainLooper() 함수의 사용에 대해서 알아 보았습니다.

지난 "runOnUiThread(Runnable) 사용하기" 포스팅을 통하여 UI 도구 키트를 UI thread에서 동작시킬 수 있는 방법을 알아 보았습니다.

이번에는 유사한 방법인 View.post(Runnable) API를 사용하여 동일한 결과를 만들어 보도록 하겠습니다.

아래 붉은색 코드는 문제가 있는 코드입니다.

이유는 별도로 생성한 스레드에서 Button UI를 변경하려고 했기 때문입니다. 

안드로이드 시스템에서는 UI 조작 및 접근은 UI thread에서만 허용합니다. (자세한 내용은 "안드로이드 메인 스레드(Android Main Thread 또는 UI Thread"포스팅 참조)

어플리케이션을 실행하여 Download 버튼을 누르면 다운로드가 완료되는 시점에 CalledFromWrongThreadException 이 발생합니다.

public class MainActivity extends Activity {
    private String TAG = "AndroidThread";
    private Button mDownloadButton;
    private Button mCancelButton;
    private Download mDownload;
    private boolean isDownloading = false;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mDownloadButton = (Button)findViewById(R.id.button_download);
        mCancelButton = (Button)findViewById(R.id.button_cancel);
    }

    public void onDownload(View view) {
        Log.d(TAG, "Press Download button");
        isDownloading = true;
        mDownload = new Download();
        mDownload.start();
    }

    public void onCancel(View view) {
        Log.d(TAG, "Press Cancel button");
        isDownloading = false;
    }

    public class Download extends Thread {

        @Override
        public void run() {
            for(int i=1;i<=10;i++) {

                if (!isDownloading) {
                    break;
                }
                try {
                    Thread.sleep(1000);
                    Log.d(TAG, "Downloading ..." + i*10 + "%");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if(i == 10) {
                    mDownloadButton.setText("Downloaded"); // CalledFromWrongThreadException 유발 코드!!
                }
            }

            isDownloading = false;
        }
    }
}

로그는 아래와 같습니다.

안드로이드 시스템은 setText()함수를 실행하고 있는 스레드가 main thead인지 검사하였고

이를 위반 하였기 때문에 CalledFromWrongThreadException 런타임 에러를 발생시켰습니다.

View.post(Runnable) API를 사용해 보도록 하겠습니다.

    public class MainActivity extends Activity {
    private String TAG = "AndroidThread";
    private Button mDownloadButton;
    private Button mCancelButton;
    private Download mDownload;
    private boolean isDownloading = false;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mDownloadButton = (Button)findViewById(R.id.button_download);
        mCancelButton = (Button)findViewById(R.id.button_cancel);
    }

    public void onDownload(View view) {
        Log.d(TAG, "Press Download button");
        isDownloading = true;
        mDownload = new Download();
        mDownload.start();
    }

    public void onCancel(View view) {
        Log.d(TAG, "Press Cancel button");
        isDownloading = false;
    }

    public class Download extends Thread {

        @Override
        public void run() {
            for(int i=1;i<=10;i++) {

                if (!isDownloading) {
                    break;
                }
                try {
                    Thread.sleep(1000);
                    Log.d(TAG, "Downloading ..." + i*10 + "%");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if(i == 10) {
                        mDownloadButton.post(new Runnable() {

                        @Override
                        public void run() {
                            Log.d(TAG, "Change Button text");
                            mDownloadButton.setText("Downloaded");
                        }
                    });
               }
            }

            isDownloading = false;
        }
    }
}

실행 로그를 보겠습니다.

"Downloading ... %" 로그는 별도로 생성한 Download 스레드에서(TID 2886)에서 실행되고 있습니다.

다운로드가 100% 완료된 시점에 실행된 mDownloadButton.post(...) 의 인자로 전달한 Runnable action 객체의 run()함수 코드가 UI thread에서(TID 2436) 실행된 것을 확인할 수 있습니다.

여기서 부터는 View.post(Runnable) API를  사용하면 어떻게 UI thread에서 Runnable 코드가 실행되는지 알아 보도록 하겠습니다.

Button 클래스는 TextView를 상속받고 있습니다. TextView는 View 클래스를 상속 받고 있구요.

post() 함수는 View 클래스의 멤버 함수입니다. 

친절하게 주석을 통하여 설명되어 있습니다.

"Runnable 작업은  메세지큐에 추가될 것입니다. 그 작업은 UI thread에서 수행될 것입니다."

주석 내용에 근거하여 Runnable action을 attachInfo.mHandler 통하여 post하면 이것이 UI thread의 Looper가 관리하는 Queue에 전달될 것임을 짐작할 수 있습니다.

이 짐작이 맞는지 코드를 따라가 보겠습니다.

먼저 위 예제 코드에서 Button 객체는 아래와 같이 Layout xml로 정의하였습니다.

Layout xml에는 화면 배치 정보가 들어 있는 파일입니다.

어플리케이션이 실행되는 시점에 Layout xml 파일은 로딩되어 각 배치 정보들이 메모리에서 객체화 됩니다.

이렇게 메모리에서 배치 정보들이 객체화 되는 과정을 Inflation이라고 합니다.

명시적으로 "new Button()" 코드를 사용하지 않아도 Button은 생성됩니다.

Button 클래스의 상속관계를 살펴 보았기 때문에 Button 객체 생성 시점에 View 클래스의 생성자가 가장 먼저 호출 될것입니다.

View 클래스의 post함수에서 사용하고 있는 attachInfo.mHandler 값이 어디서 채워지는지 보겠습니다. 

안드로이드 시스템에서 어플리케이션이 실행될때  MainActivity와 MainActivity에 배치될 Button과 같은 View 들이 생성됩니다.

이 과정은 ActivityThread에서 시작됩니다.

ActivityThread는 ZygoteInit에 의해서 실행되면서 아래와 같이 main함수에서 UI thread looper를 생성합니다.

아래 콜스택은 MainActivity의 onCreate 함수가 호출되기까지의 콜스택입니다.

위의 콜스택에서 파란색으로 표시된 handleLaunchActivity를 잠시 따라가 보겠습니다.

위의 함수 호출과정을 통해 ActivityThread의 main 함수에서 시작된 스레드가 ViewRootImpl객체를 생성했다는 것을 알 수 있습니다.

바로 이 스레드가 앞서 보았듯이 Main Looper를 생성한 UI 스레드입니다.

다시 ViewRootImpl 객체 생성과정을 계속 따라 가겠습니다.

ViewRootImpl 객체가 생성되면서 ViewRootHandler를 생성하여 View.mAttachInfo 객체 생성시에 사용합니다.

여기까지 코드를 간단히 보았습니다. 이제 View 클래스의 post 함수에서 본 attachInfo.mHandler 값이 어디서 채워지는지 확인 할 단계입니다.

결과적으로 attachInfo.mHandler.post(action) 코드는 아래와같은 과정을 거칩니다.

action은 ViewRootImpl 객체에서 생성한 핸들러를 통해서 메세지 Queue에 삽입됩니다.

이 Queue는 ActivityThread가 생성한 Main Looper를 통해서 처리됩니다.

참고로 하나의 스레드에는 여러개의 Handler가 동작할 수 있습니다. 

그리고 하나의 스레드는 단 하나의 Looper만 가질수 있고 Looper는 하나의 Queue와 연결되어 있습니다.

요약하면 post 함수는 action을 ViewRootImpl객체가 생성한 Handler로 전달하고 이 Handler에 의해서 ActivityThread가 생성한 Main Looper에 연결된  Queue에 삽입됩니다.

그리고 Main Looper는 이 Queue에서 action을 꺼내서 UI thread상에서 코드를 실행하게 됩니다. 

지금까지 View.post() 함수의 사용법과 동작 원리를 간단하게 알아보았습니다.

Android 에서 음성을 녹음할 때 사용할 수 있는 API 는 여러가지가 있지만, 지난 포스팅에서 가장 대표적으로 사용되는 AudioRecord API 를 이용한 예제를 다루어 보았습니다.

이번 포스팅에서는 MediaRecorder API 를 이용한 음성 녹음 예제를 다루어 보겠습니다.

AudioRecord 를 이용한 예제처럼 간단하게 완성할 수 있습니다.

1. main layout 구성하기

layout 은 간단히 버튼을 두개 놓고, 하나는 녹음 시작/정지, 다른 하나는 녹음된 컨텐츠를 재생/정지 하도록 구현해 보겠습니다.

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.codetravel.mediarecorder.MainActivity">

    <Button
        android:id="@+id/bt_record"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Start Recording"/>

    <Button
        android:id="@+id/bt_play"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Start Playing"/>
</LinearLayout>

이를 위해 bt_record 와 bt_play 를 각각 layout 에 추가 하고, MainActivity 에서 각각의 버튼에 대한 OnClickListener() 를 구현 해 줍니다.

OnClickListener() 에서는 현재 레코딩 상태에 따라서 recorder 를 Start 하거나 Stop 하는 부분이 구현될 것입니다.

2. MediaRecorder 생성 후 레코딩 준비하기

recorder 를 start 하기에 앞서, MediaRecorder 객체를 하나 생성 하고 레코딩 할 파일의 포맷, 인코더 등등을 설정 해 줍니다.

    @Override                                                     
    protected void onCreate(Bundle savedInstanceState) {          
        super.onCreate(savedInstanceState);                       
        setContentView(R.layout.activity_main);    

        mRecorder = new MediaRecorder();                          
    }    

    // 레코더 기본 설정 
    void initAudioRecorder() {                                                                
        mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);                              
        mRecorder.setOutputFormat(MediaRecorder.OutputFormat.AAC_ADTS);                       
        mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);                            
                                                                                              
        mPath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/record.aac";  
        Log.d(TAG, "file path is " + mPath);                                                  
        mRecorder.setOutputFile(mPath);                                                       
        try {                                                                                 
            mRecorder.prepare();                                                              
        } catch (Exception e) {                                                               
            e.printStackTrace();                                                              
        }                                                                                     
    }                                                                                                                                                 

initAudioRecorder() 함수 안에다가 MediaRecorder prepare 단계 까지 모든 설정들을 구현 합니다.

MediaRecorder 의 State Diagram 을 참고하면, 한번 MediaRecorder 를 Stop 할 시에, 각종 설정들을 다시 해 주어야 하기 때문에 함수로 분리하여 구현하는 것이 추후 더 편리합니다.

3. 녹음 시작/ 정지

isRecording 이라는 flag 를 두어 현재 녹음 중인지 아닌지를 구분 할 수 있습니다.

현재 녹음중이 아니면 initAudioRecorder(), start() 를 수행 하여 녹음을 시작하고, 녹음중 일 경우에는 stop() 을 호출하여 녹음을 정지합니다.

isRecording flag 와 button 의 text 는 현재 상태에 맞게 update 합니다.

    boolean isRecording = false;                                                                      
    Button mBtRecord = null;                                       
                                                                  
    @Override                                                     
    protected void onCreate(Bundle savedInstanceState) {          
        ..
        mBtRecord = (Button) findViewById(R.id.bt_record);        
        mBtRecord.setOnClickListener(new View.OnClickListener() { 
            @Override                                             
            public void onClick(View v) {                         
                if (isRecording == false) {                       
                    initAudioRecorder();                          
                    mRecorder.start();                            
                                                                  
                    isRecording = true;                           
                    mBtRecord.setText("Stop Recording");          
                } else {                                          
                    mRecorder.stop();
                             
                    isRecording = false;                          
                    mBtRecord.setText("Start Recording");         
                }                                                 
            }                                                     
        });                                                       

4. 재생 시작하기

재생 버튼에 대한 onClickListener 를 생성하고 재생을 위한 MediaPlayer 객체를 하나 생성합니다.

버튼이 한번 클릭 되었을 때, setDataSource/prepare/start 과정을 진행 해줍니다.

'MediaPlayer' 도 MediaRecorder 와 같이 State Diagram 을 참고하여 각 State 에 맞는 함수를 호출해 주어야 합니다.

한번 Stop 을 호출 하게 되면 stopped 상태가 되어 다시 started 상태로 가기 위해서는 prepare/start 함수를 순차적으로 호출해야 합니다.

=> 만약 현재 상태에서 부를 수 없는 함수를 호출하는 경우 ( 예를들어 stopped 상태에서 prepare를 호출하지 않고 start 부터 호출하는 경우)에는 IllegalStateException 이 발생하니 주의 해야 합니다.

 
    MediaPlayer mPlayer = null;
    boolean isPlaying = false;
    Button mBtPlay = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ..
        mBtPlay = (Button) findViewById(R.id.bt_play);
        mBtPlay.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (isPlaying == false) {
                    try {
                        mPlayer.setDataSource(mPath);
                        mPlayer.prepare();
                    }catch (Exception e) {
                        e.printStackTrace();
                    }
                    mPlayer.start();

                    isPlaying = true;
                    mBtPlay.setText("Stop Playing");
                }
                else {
                    mPlayer.stop();

                    isPlaying = false;
                    mBtPlay.setText("Start Playing");
                }
            }
        });

        mPlayer = new MediaPlayer();
        mPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
            @Override
            public void onCompletion(MediaPlayer mp) {
                isPlaying = false;
                mBtPlay.setText("Start Playing");
            }
        });
    }

MediaPlayer는 onCompletion callback method 를 제공해 주고 있어서, 파일 재생이 끝날 경우에 대한 처리를 편리하게 해 줄 수 있습니다.

파일 재생이 완료되면 isPlaying flag 를 false 로 설정 하고, 버튼의 Text 를 변경해 주는 일을 수행하도록 구현 하였습니다.

여기까지 진행하면 음성을 녹음하고 재생하는 코드가 완성 됩니다. 상세 코드는 'github 코드' 를 참고하세요.

현재는 음성 녹음 뿐이지만 다음 포스팅에서는 카메라로 들어오는 Video 컨텐츠도 함께 레코딩 하여 비디오 파일을 만들어 보도록 하겠습니다.

Android 에서 제공하는 Recording API 중, 지난번에 보았던 AudioRecorder 말고 더 편리한 MediaRecorder 가 있습니다.

AudioRecorder 는 오디오만 레코딩 가능 하지만, MediaRecorder 의 경우 Audio 및 Video 컨텐츠의 레코딩이 가능 합니다.

다만 인코딩 된 파일을 받기 때문에 AudioRecorder 처럼 PCM Data 를 바로 받아올 수는 없는 단점이 있습니다.

본인이 구현하려는 레코더의 사용 용도에 맞게 AudioRecorder/MediaRecorder 를 선택하여 사용하시면 되겠습니다.

Android Developer 의 MediaRecorder API Guide 를 참고하면, MediaRecorder 는 아래와 같은 state machine 을 갖습니다.

따라서 MediaRecorder API 를 사용할 때는 아래의 State 를 잘 따라서 코딩해야 합니다. 예를들어 Initail 상태에서는 바로 Prepared 상태로 갈 수 없고, Initailized 와 DataConfigured 상태를 거쳐야지 Prepared 상태가 될 수 있습니다.

이를 어기게 되면 StateIllegalException 이 발생하고, 원하는 동작을 얻을 수 없으니 조심해야 합니다.

Android Developer 사이트에서 설명하는 일반적인 Recording Flow 는 아래 코드와 같습니다.

각 단계별로 실제 레코딩시 일어나는 동작들에 대해 살펴보도록 하겠습니다.

MediaRecorder recorder = new MediaRecorder();
 recorder.setAudioSource(MediaRecorder.AudioSource.MIC); //----------- (1)
 recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP); // -- (2)
 recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB); // ------(3)
 recorder.setOutputFile(PATH_NAME);
 recorder.prepare(); // -----------------------------------------------(4)
 recorder.start();   // Recording is now started ----------------------(5)
 ...
 recorder.stop();
 recorder.reset();   // You can reuse the object by going back to setAudioSource() step
 recorder.release(); // Now the object cannot be reused

(1) AudioSource 설정

AudioSource 의 종류는 아래 표에 정리되어 있습니다.

보통은 마이크로 들어오는 음성을 많이 녹음하기 때문에 MIC 값을 많이 사용하고, 용도에 맞게 그 외의 값들을 설정할 수 있습니다.

제일 아래 RADIO_TUNER 와 HOTWORD 는 System API 로 일반 Application 에서는 사용 불가 합니다.

setAudioSource 함수가 호출되지 않을 경우에는 output file 에 audio track 이 포함되지 않습니다. 즉, 오디오가 녹음되지 않는다는 이야기입니다.

오디오를 녹음하고 싶으면 setAudioSource 함수를 prepare 전에 꼭 호출해 주어야 합니다.

(2) Output Format 설정

레코딩 후 실제 파일로 저장할 때, 저장할 파일의 format 을 설정해 줄 수 있습니다. 

비디오 포맷으로 가장 많이 사용되는 THREE_GPP 혹은 MPEG_4 가 있고, 오디오만 녹음 할 경우에는 오디오 전용 파일포맷인 AMR 이나 AAC 가 많이 사용 됩니다.

setOutputFormat() 함수는 setAudioSource()/setVideoSource() 호출 이후 / prepare() 이전에 호출되어야 합니다.

(3) AudioEncoder 설정

Audio Recording 시 Audio Encoder 를 설정해 주는 함수 입니다. 이 함수를 호출하지 않을 경우에 녹음된 파일에 audido track 은 포함되지 않습니다.

즉, 이 함수도 setAudioSource 와 동일하게 오디오를 녹음하고 싶다면 setOutputFormat() 이후 / prepare() 이전에 꼭 호출해 주어야 합니다.

(4) prepare

prepare 단계는 앞서 설정한 설정값들로 recording 을 준비하는 단계 입니다.

때문에 이 함수는 audio/video source와 audio/video encoder 를 모두 설정하고 file format 을 확정 지은 후에 불려야 합니다.

이 함수가 불리면 위의 State Machine 에서 recorder 는 prepared 상태가 되어 start 나 reset 을 호출할 수 있습니다.

(5) start

start 함수를 호출하면 정해놓은 audio/video source 에서 실제 레코딩을 시작하게 되고, state 는 Recording 상태가 됩니다.

start 이후 원하는 시점에 stop 을 호출하면, 그 시점까지 레코딩이 진행 됩니다.

이 외에도 API Level 24 부터 제공되는 pause() / resume() 함수를 이용해 레코딩을 잠시 멈추는 것이 가능합니다.

stop() 과 다르게 pause() 함수로 레코딩을 멈추면 기존의 configuration 은 유지된 채로 MediaRecorder 가 잠시 멈추게 됩니다.

이 상태에서 resume() 함수로 레코딩을 다시 시작할 수 있습니다. 당연한 이야기지만 paused 상태에서 레코딩 되는 내용은 버려지게 됩니다.

developer 사이트를 참고하면 위의 간단한 API 이외에도 MediaRecorder 에서 제공하는 다양한 API 들을 볼 수 있으니 참고하시면 되겠습니다.

https://developer.android.com/reference/android/media/MediaRecorder.html

다음 포스팅에서는 MediaRecorder 를 이용한 실제 레코딩 예제를 살펴보도록 하겠습니다.

앞서 안드로이드 "안드로이드 메인 스레드 포스팅"을 통하여 메인스레드의 특징에 대해서 알아보았습니다. 

그 중에서 메인 스레드가 아닌 스레드에서 Button UI를 조작하다가 CalledFromWrongThreadException를 경험하기도 하였습니다.

이런 문제를 해결할 수 있는 방법에 대해서 알아보겠습니다.

Activity.runOnUiThread(Runnable) 사용

Developer Android 사이트에서 찾아보면 다음과 같이 설명이 있습니다.

설명 중 다음 부분이 우리가 처한 상황을 설명해 주고 있습니다.

"특정 동작을 UI 스레드에서 동작하도록 합니다. 만약 현재 스레드가 UI 스레드이면 그 동작은 즉시 수행됩니다."

하지만 "현재 스레드가 UI 스레드가 아니면, 필요한 동작을 UI 스레드의 이벤트 큐로 전달한다" <== 이부분 입니다.

우선 설명을 믿고 코드를 만들어 보겠습니다. 먼저 CalledFromWrongThreadException를 발생시켰던 코드는 아래와 같습니다.

 
    public class MainActivity extends Activity {
    private String TAG = "AndroidThread";
    private Button mDownloadButton;
    private Button mCancelButton;
    private Download mDownload;
    private boolean isDownloading = false;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mDownloadButton = (Button)findViewById(R.id.button_download);
        mCancelButton = (Button)findViewById(R.id.button_cancel);
    }

    public void onDownload(View view) {
        Log.d(TAG, "Press Download button");
        isDownloading = true;
        mDownload = new Download();
        mDownload.start();
    }

    public void onCancel(View view) {
        Log.d(TAG, "Press Cancel button");
        isDownloading = false;
    }

    public class Download extends Thread {

        @Override
        public void run() {
            for(int i=1;i<=10;i++) {

                if (!isDownloading) {
                    break;
                }
                try {
                    Thread.sleep(1000);
                    Log.d(TAG, "Downloading ..." + i*10 + "%");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if(i == 10) {
                    mDownloadButton.setText("Downloaded"); // CalledFromWrongThreadException 유발 코드!!
                }
            }
            isDownloading = false;
        }
    }
}

public class MainActivity extends Activity {
    private String TAG = "AndroidThread";
    private Button mDownloadButton;
    private Button mCancelButton;
    private Download mDownload;
    private boolean isDownloading = false;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mDownloadButton = (Button)findViewById(R.id.button_download);
        mCancelButton = (Button)findViewById(R.id.button_cancel);
    }

    public void onDownload(View view) {
        Log.d(TAG, "Press Download button");
        isDownloading = true;
        mDownload = new Download();
        mDownload.start();
    }

    public void onCancel(View view) {
        Log.d(TAG, "Press Cancel button");
        isDownloading = false;
    }

    public class Download extends Thread {

        @Override
        public void run() {
            for(int i=1;i<=10;i++) {

                if (!isDownloading) {
                    break;
                }
                try {
                    Thread.sleep(1000);
                    Log.d(TAG, "Downloading ..." + i*10 + "%");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if(i == 10) {

                    (MainActivity.this).runOnUiThread(new Runnable(){

                        @Override
                        public void run() {
                            Log.d(TAG, "Change Button text");
                            mDownloadButton.setText("Downloaded");
                        }
                    });
                }
            }

            isDownloading = false;
        }
    }
}

다음은 runOnUiThread 함수를 사용한 코드입니다.

public class MainActivity extends Activity {
    private String TAG = "AndroidThread";
    private Button mDownloadButton;
    private Button mCancelButton;
    private Download mDownload;
    private boolean isDownloading = false;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mDownloadButton = (Button)findViewById(R.id.button_download);
        mCancelButton = (Button)findViewById(R.id.button_cancel);
    }

    public void onDownload(View view) {
        Log.d(TAG, "Press Download button");
        isDownloading = true;
        mDownload = new Download();
        mDownload.start();
    }

    public void onCancel(View view) {
        Log.d(TAG, "Press Cancel button");
        isDownloading = false;
    }

    public class Download extends Thread {

        @Override
        public void run() {
            for(int i=1;i<=10;i++) {

                if (!isDownloading) {
                    break;
                }
                try {
                    Thread.sleep(1000);
                    Log.d(TAG, "Downloading ..." + i*10 + "%");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if(i == 10) {
                       (MainActivity.this).runOnUiThread(new Runnable(){

                        @Override
                        public void run() {
                            Log.d(TAG, "Change Button text");
                            mDownloadButton.setText("Downloaded");
                        }
                    });
                }
            }

            isDownloading = false;
        }
    }
}

run()함수를 오버라이드하여 Runnable 인터페이스를 구현하였습니다. 

이제 run() 함수에 있는 작업은(여기서는 setText함수 실행이겠죠) main thread(UI thread) 에서 실행 됩니다. 

로그로 확인 해보겠습니다.   

다운로드 진행 상태를 출력하는 로그는 TID3467 thread에서 동작합니다. 

의도한대로 다운로드 완료 후,  setText 함수를 수행하는 run 함수가 UI thread에서 실행된 것을 확인 할 수 있습니다.

다음 그림은 다운로드 버튼의 텍스트가 정상적으로 변경된 모습입니다.

runOnUiThread 함수는 어떻게 이런 일을 할까요? xref에서 runOnUiThread 함수를 살펴 보겠습니다.

"특정 동작을 UI 스레드에서 동작하도록 합니다. 만약 현재 스레드가 UI 스레드이면 그 동작은 즉시 수행됩니다."

하지만 "현재 스레드가 UI 스레드가 아니면, 필요한 동작을 UI 스레드의 이벤트 큐로 전달합니다"  설명이 그대로 코드화 되어 있네요

runOnUiThread가 실행된 스레드는 TID3467이므로 즉 UI thread가 아니므로 mHandler.post(action) 코드가 실행됩니다.

mHandler.post(action)을 실행하면 아래와 같이 순서대로 함수가 호출됩니다.(1 -4)

결과적으로 Runnable r은 UI thread의 queue에 메시지 형식으로 enqueue가 됩니다. 

후에 queue에 있는 메세지를 꺼내서 UI thread에서 동작을 수행할 것입니다.

1. post(Runnable r)

2. sendMessageDelayed(Message msg, long delayMillis)

3. sendMessageAtTime(Message msg, long uptimeMillis)

 - MessageQueue queue = mQueue;

4. enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)

간략하게 말씀드리면 처음 startActivity() 함수를 통해서 MainActivity가 생성되는 과정은 zygoteInit에 의해서 ActivityThread가 생성됩니다.

ActivityThread는 아래와 같이 Main Looper와 Handler를 생성합니다. 

이것이 안드로이드 시스템에서 자동으로 생성되는 UI thread의  Looper와  Handler 입니다. 

그리고 ActivityThread는 ActivityManagerService 와 바인더 통신을 하여 MainActivity를 생성하게 됩니다. 

따라서 ActivityThread가 생성한 MainActivity는 ActivityThread에서 생성한 Looper와 Handler를 사용하게 됩니다.

즉 위의 3번에서 mQueue는 UI thread의 Looper가 관리하는 queue를 가리킵니다.

결국 queue에 메세지 형태로 들어간 Runnable 작업은 UI Thread에서 dequeue 되어 UI Thread상에서 수행됩니다.

 UI thread에서 Button의 Text 변경 작업을 했기 때문에 CalledFromWrongThreadException와 같은 문제가 발생하지 않는 것입니다.

아래 콜스택은 MainActivity 액티비티의 onCreate가 불리는 함수 호출 과정입니다.

ActivityThread의 main 함수에서 실행된 Looper.loop() 함수에 의해서 메세지가 처리되고 있는것을 볼 수 있습니다.

그리고 MainActivity가 생성되면서 onCreate가 호출됩니다.

위의 과정은 붉은색으로 표시된 "main"이라는 표시로 main thread 즉 UI thread의  콜스택임을 알 수 있습니다.  

이상으로 runOnUiThread 함수의 사용에 대해서 간략하게 보았습니다.

안드로이드 어플리케이션이 실행되면 안드로이드 시스템은 하나의 실행 스레드로 어플리케이션의 프로세스를 실행합니다. 

어플리케이션의 구성 요소가 생성될 때 별도의 스레드가 생성되는 것은 아니며 앞서 말한 하나의 실행 스레드에서 실행됩니다. 이 스레드를 Main thread라고 합니다.

안드로이드 시스템에 의해 생성된 이 Main thread는 화면 구성에 관한 역할을  담당합니다.  

예를 들어 Button, CheckBox, TextView 등의 UI도구 키트 구성 요소를 생성 및 조작하였을 때 상호작용하는 스레드가 Main Thread입니다. 

그래서 Main thread를 UI thread라고도 합니다.  

Main thread에 대해서 좀더 이야기하기 전에 우리가 만든 어플리케이션에서 main thread가 존재하고 있는 모습을 잠시 보도록 하겠습니다.

안드로이드 스튜디오를 열어 Empty Activity를 추가하고 별도의 코드 추가없이 빌드 한 후 APK를 실행해 보았습니다. 

이 때 adb shell 명령어를 사용하여 실행된 APK의 스레드를 출력해보면 아래와 같습니다.(ps PID -t)

붉은 박스로 표시된 부분이 main thread입니다. 참고로 실행된 APK는 PID 26914, main thread TID 26914입니다.

그리고 프로세스간 통신을 위해 사용되는 바인더 스레드와 그외 런타임 내부 스레드들이 존재합니다. 

안드로이드 시스템은 빈 액티비티만 존재하는 어플리케이션일지라도 이렇게 여러 스레드들을 기본적으로 생성하고 있습니다.

바인더 스레드와 그외 내부 스레드라고 표시한 부분을 아는 것도 필요하겠지만 지금은 main thread에 초점을 맞추도록 하겠습니다.

Main thread에 대해서 좀더 알아보겠습니다. 

어플리케이션을 실행했을 때, 버튼을 누르거나 화면터치를 했는데 반응성(응답성)이 떨어진다면 사용자는 답답함을 느낄 것입니다.

그리고 간혹  ANR이 발생하여 어플리케이션이 강제 종료되는 것을 본 경험도 있을 것입니다.

반응성은 Main thread(UI thread)와 실제 작업이 실행되는 스레드간의 관계와 연관이 있습니다.

실제 작업이라고 하면 예를 들어 동영상 다운로드 버튼을 눌렀을 때 "네트워크를 통하여 동영상 데이터를 다운로드 하는 작업"을 의미 할 수 있을 것입니다.

사용자가 다운로드 버튼을 누르면 동영상 데이터 다운로드가 시작될 것입니다. 

만약 개발자가 데이터를 다운로드하는 작업을 Main Thread(UI thread) 에 구현하였다면 다운로드가 완료될 때까지 화면은 멈추어있는 것처럼 보일것입니다.

이런것들이 어플리케이션의 반응성을 떨어지게 만들고 사용자는 답답함을 느끼게 됩니다.

반응성 좋은 어플리케이션을 만드려면 시간이 오래걸리는 작업은 main thread에 구현하지 않고 별도의 스레드에서 동작하도록 구현하면 됩니다.

그리고 안드로이드 UI 도구 키트는 스레드로부터 세이프하지 않습니다. 

그렇기 때문에 UI thread가 아닌 스레드(직접 생성한 별도의 스레드)에서는 UI 구성요소를  조작하는 것은 허용되지 않습니다. ( 스레드 세이프 하다는 의미는 여러 스레드에서 동시에 사용해도 정상적으로 동작한다는 의미입니다)

그렇다면 UI 구성 요소는 모두 UI thread에서 조작되어야 하고 결국은 UI 입장에서는 보면 UI 동작은 단일 스레드로 동작하는 구조가 됩니다. 

따라서 UI thread에서 시간이 오래 걸리는 작업을 수행하는 것은 그 작업이 수행되는 동안 UI업데이트가 지연(또는 차단)되고 있다는 것을 의미합니다.

이런 이유로 시간이 오래 걸리는 작업은 별도의 스레드를 생성하여 UI thread로 부터 분리해야 반응성이 좋은 프로그램을 만들 수 있습니다.

다시 말하면 오래 걸리는 작업을 별도의 스레드를 생성한 후 그 스레드에서 동작시키면 됩니다.

위에서 이야기했던, 안드로이드 스레드 사용시 유의 사항을 정리하면 다음의 2가지 입니다.

1. 시간이 오래 걸리는 작업은 UI 스레드로 부터 분리하고 별도의 스레드에서 실행함으로써 UI 스레드 작업이 지연(또는 차단)되는 것을 방지합니다 .

2. UI 스레드가 아닌 스레드에서는 UI 구성 요소를 조작하지 않습니다.

지금부터는 1번, 2번 사항에 대해서 예제 코드로 하나씩 살펴보도록 하겠습니다.

예제 코드는 "Download" 버튼과 "Cancel" 버튼이 존재합니다. "Download" 버튼을 누르면 1초에 한번씩 다운로드 상태로그를 출력하도록 하였습니다. 

예제 코드에서는 단순히 로그를 출력하는 것이지만 실제로 데이터를 다운로드한다고 가정해도 좋습니다.(예제 코드니까요)

그리고 "Cancel" 버튼을 누르면 취소되었다는 로그를 출력합니다. 

이것 역시 실제로는 다운로드를 취소한다고 가정합니다.

그럼 예제 코드를 보겠습니다.

public class MainActivity extends Activity {
    private String TAG = "AndroidThread";
    private Button mDownloadButton;
    private Button mCancelButton;
    private Download mDownload;
    private boolean isDownloading = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mDownloadButton = (Button)findViewById(R.id.button_download);
        mCancelButton = (Button)findViewById(R.id.button_cancel);
    }

    public void onDownload(View view) {  // Download 버튼 누르면 호출되는 함수
        Log.d(TAG, "Press Download button");
        isDownloading = true;

        for(int i=1;i<=10;i++) { // 데이터 다운로드 작업(사실은 단순 로그 출력입니다^^)

            if (!isDownloading) {
                break;
            }
            try {
                Thread.sleep(1000);
                Log.d(TAG, "Downloading ..." + i*10 + "%");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        isDownloading = false;
    }

    public void onCancel(View view) { // Cancel 버튼 누르면 호출되는 함수
        Log.d(TAG, "Press Cancel button");
        isDownloading = false;
    }
}

아래 로그는 "Download" 버튼을 한번 눌렀을 때 출력되는 로그입니다.

22509-22509를 보아 PID22509 TID22509 이므로 main thread에서 다운로드 작업이 동작하고 있음을 알 수 있습니다.

별도의 스레드 생성없이 다운로드 코드를 작성하였기 때문에 당연한 결과입니다.

어쨌든 다운로드는 100% 완료되었습니다.

이번에는 "Download" 버튼을 누른 후, 바로 "Cancel"  버튼을 2~3번 정도 눌러 보겠습니다.

아래와 그림처럼  ANR(Application Not Responding) 다이얼로그가 발생하였습니다.

사용자가 "Cancel" 버튼을 눌렀지만 5초 이상 UI가 멈춰있었기 때문에 안드로이드 시스템에서 발생시킨 에러 다이얼로그입니다.

반응성(응답성)이 좋지못한 어플리케이션의 사례가 되겠습니다.

로그를 통해 좀더 자세히 보겠습니다.

60% 다운로드 로그 출력 이후에 ANR 로그가 생성된 것을 볼 수 있습니다.

5.7초 정도 서스펜드되었다는 로그도 함께 보입니다.

그리고 "Download" 버튼을 누른 직후 "Cancel" 버튼을 바로 눌렀지만 다운로드는 중단 되지 않았습니다.

취소 로그 출력은 다운로드 100% 완료된 후에 찍혔습니다.

이유는 앞에서도 언급했듯이 main thread에서 "Download"와 "Cancel" 버튼 처리와 다운로드 작업을 모두 처리하기 때문에 단일 스레드로 동작하는 구조입니다.

따라서 "Cancel" 버튼보다 먼저 실행된 다운로드 작업이 완료되기 전에는 취소 로그가 출력되지 않는 것입니다.

ANR을 회피하고 반응성 좋은 프로그램을 만들기 위해서 1번 사항인 시간이 오래 걸리는 작업은 UI thread로 부터 분리하라 는 의미를 알 수 있었습니다.

별도의 스레드를 생성하여 다운로드 작업(오래걸리는 작업)을 UI 스레드에서 분리하도록 하겠습니다.

public class MainActivity extends Activity {
    private String TAG = "AndroidThread";
    private Button mDownloadButton;
    private Button mCancelButton;
    private Download mDownload;
    private boolean isDownloading = false;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mDownloadButton = (Button)findViewById(R.id.button_download);
        mCancelButton = (Button)findViewById(R.id.button_cancel);
    }

    public void onDownload(View view) {
        Log.d(TAG, "Press Download button");
        isDownloading = true;
        mDownload = new Download();  // Download 스레드 생성
        mDownload.start();  // Download 스레드 시작
    }

    public void onCancel(View view) {
        Log.d(TAG, "Press Cancel button");
        isDownloading = false;
    }

    public class Download extends Thread{  // 다운로드 작업을 위한 스레드입니다.

        @Override
        public void run() {
            for(int i=1;i<=10;i++) { // 이제 다운로드 작업은 Download 스레드에서 동작합니다.

                if (!isDownloading) {
                    break;
                }
                try {
                    Thread.sleep(1000);
                    Log.d(TAG, "Downloading ..." + i*10 + "%");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            isDownloading = false;
        }
    }
}

이번에는 "Download"버튼을 누르고 약 3초 후에 "Cancel"버튼 3~4번  눌러보겠습니다.

취소 버튼을 누른 후에 다운로드가 중지되는 것을 볼 수 있습니다.

이렇게 취소 버튼이 바로 실행될 수 있는 이유는 다운로드 작업이 TID13679 스레드에서 동작하고 있기 때문입니다.

이제 이 프로그램은 main thread와 별도로 생성한 스레드가 멀티로 동작하는 프로그램입니다.

이전보다 반응성이 좋아진 것을 확인할 수 있었습니다.

UI 편의성을 위해서 한가지 기능을 더 추가해 보겠습니다.

다운로드가 완료되면 "Download"버튼의 텍스트를 "Downloaded"으로 바꿔 보도록 하겠습니다

추가된 코드는 아래와 같습니다.

public class Download extends Thread {

        @Override
        public void run() {
            for(int i=1;i<=10;i++) {

                if (!isDownloading) {
                    break;
                }
                try {
                    Thread.sleep(1000);
                    Log.d(TAG, "Downloading ..." + i*10 + "%");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if(i == 10) {
                    mDownloadButton.setText("Downloaded"); // 다운로드가 완료되면 버튼의 텍스트를 Downloaded로 변경
                }
            }

            isDownloading = false;
        }
    }

이제 실행해보면 "Unfortunately, AndroidThread has stopped." 라는 에러 팝업을 발생시키면서 어플리케이션은 종료됩니다.

아래의  로그에서와 같이 Exception이 발생하였습니다.

CalledFromWrongThreadException 이 발생하였습니다.

그리고 "Only the original thread that created a view hierarchy can touch its views" 라고 부연 설명을 해줍니다.

직역하면 뷰 계층 구조를 만든 원래 스레드(main thread)만 해당 뷰를 조작할 수 있다는 의미입니다.

안드로이드 시스템은 setText()함수를 실행하고 있는 스레드가 main thead인지 검사하였고

이를 위반 하였기 때문에 런타임 에러를 발생시킨 것입니다.

위 로그를 보면 TID18037 setText() 함수가 실행되었습니다. main thread인 TID18227 에서 실행되어야 합니다.

이제서야 UI 구성요소는 main thread(UI thread) 에서만 동작시켜야 한다는 2번 사항이 떠오릅니다.

그렇다면 이 문제를 해결할 수 있는 방법은 무엇일까요?

setText() 함수 호출같은 UI구성 키트 조작을 main thread에서 동작하도록 해줘야 합니다.

안드로이드에서는 다양한 방법으로 이것을 지원하고 있습니다.

1.  Activity.runOnUiThread(Runnable) 사용

2. View.post(Runnable) 사용

3. AsyncTask 사용

다음 포스팅에서 위의 3가지 방법을 하나씩 살펴봄으로써 CalledFromWrongThreadException 에러를 해결해보고

어떻게 UI구성 요소를 main thread에서 조작하는지 알아보도록 하겠습니다.

Android 에서 제공하는 AudioRecord Class 를 사용하면 음성녹음 기능을 쉽게 구현할 수 있습니다.

Application 에서는 AudioRecord Class 에서 제공하는 세가지 형태의 read method를 통해서 음성 데이터를 가져올 수 있습니다.

- read(byte[], int, int), read(short[], int, int), read(ByteBuffer, int)

어떤 형태의 함수를 쓸 것인지는 Application 에서 다루는 Data 형태에 따라 사용자가 결정하면 됩니다.

이 포스팅에서는 간단한 음성녹음 예제를 다루어 볼 것입니다.

간단하게 버튼 두개를 두고, 하나의 버튼으로는 녹음 시작/정지 를 수행하고, 다른 하나의 버튼으로는 재생/정지를 구현해 보도록 하겠습니다.

1. main layout 에 button 추가 하기

Record Button 과 Play Button 을 추가하고, 각각 Button 이 클릭 되면 해당 동작을 수행할 함수 onRecord/onPlay 를 정의 합니다.

<Button
    android:id="@+id/bt_record"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="Record"
    android:onClick="onRecord"/>

<Button
    android:id="@+id/bt_play"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="Play"
    android:onClick="onPlay"/>

2. AudioRecord 생성 및 초기화

AudioRecord 생성자를 보면, AudioRecord 객체를 생성하기 위해 필요한 인자들을 확인 할 수 있습니다.

- public AudioRecord(int audioSource, int sampleRateInHz, int channelConfig, int audioFormat, int bufferSizeInBytes)

첫번째 인자인 AudioSource 의 경우 MediaRecorder.AudioSource 에 int 값이 정의되어 있고, Mic 로 들어오는 음성을 녹음하기 위해서는 1의 값을 넣어주면 됩니다.

두번째 세번째 네번째 인자는 실제 녹음될 오디오 데이터의 samplerate / channel / format 값을 의미합니다.

Sample Rate 는 아날로그 신호를 디지털로 변환 할 때, 1초당 몇개의 sample 을 추출할 것인가에 대한 내용으로 보통 8000Hz~48000Hz 가 많이 사용됩니다. 물론 값이 클수록 아날로그 신호와 비슷한 형태가 되니 고음질의 컨텐츠가 되겠지요.

Channel 값은 mono/streo 중에 선택하면 되고, audioformat 의 값은 PCM Data 를 받을 것이기 때문에 AudioFormat.ENCODING_PCM_16BIT 를 넣어주도록 하겠습니다.

마지막으로 buffer size 는 한번에 전달 받을 audio data 의 크기를 나타내고, 보통은 AudioRecord 의 getMinBufferSize 함수를 호출해서 return 되는 값으로 지정을 해줍니다.

public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";

    private int mAudioSource = MediaRecorder.AudioSource.MIC;
    private int mSampleRate = 44100;
    private int mChannelCount = AudioFormat.CHANNEL_IN_STEREO;
    private int mAudioFormat = AudioFormat.ENCODING_PCM_16BIT;
    private int mBufferSize = AudioTrack.getMinBufferSize(mSampleRate, mChannelCount, mAudioFormat);

    public AudioRecord mAudioRecord = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mAudioRecord = new AudioRecord(mAudioSource, mSampleRate, mChannelCount, mAudioFormat, mBufferSize);
        mAudioRecord.startRecording();
    }

여기까지 하면 실제 레코딩 할 준비가 완료 되었고, 다음은 실제 레코딩을 시작해 보도록 하겠습니다.

3. 녹음 시작 - PCM Data 가져오기

녹음을 시작하고 PCM Data 를 가져오는 부분은 UI가 멈춰보이지 않도록 별도의 Thread 로 분리해야 합니다. 

이를 위해 mRecordThread 를 추가로 정의하고, 레코딩 중인지 아닌지를 알기 위해 isRecording 이라는 boolean 변수를 정의하였습니다.

mRecordThread 는 onCreate 함수 내부에 정의를 해놓고, 실제 start 되는 것은 사용자가 버튼을 누른 순간에 이루어지도록 합니다.

읽어온 PCM 데이터를 파일에 쓰기 위해 filepath 를 지정해 주고, FileOutputStream 을 통해 file open/write/close 를 수행하였습니다.

    public Thread mRecordThread = null;
    public boolean isRecording = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ..
        mRecordThread = new Thread(new Runnable() {
            @Override
            public void run() {
                byte[] readData = new byte[mBufferSize];
                mFilepath = Environment.getExternalStorageDirectory().getAbsolutePath() +"/record.pcm";
                FileOutputStream fos = null;
                try {
                    fos = new FileOutputStream(mFilepath);
                } catch(FileNotFoundException e) {
                    e.printStackTrace();
                }

                while(isRecording) {
                    int ret = mAudioRecord.read(readData, 0, mBufferSize);  //  AudioRecord의 read 함수를 통해 pcm data 를 읽어옴
                    Log.d(TAG, "read bytes is " + ret);

                    try {
                        fos.write(readData, 0, mBufferSize);    //  읽어온 readData 를 파일에 write 함
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                }

                mAudioRecord.stop();
                mAudioRecord.release();
                mAudioRecord = null;

                try {
                    fos.close(); 
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    public void onRecord(View view) {
        if(isRecording == true) {
            isRecording = false;
            mBtRecord.setText("Record");
        }
        else {
            isRecording = true;
            mBtRecord.setText("Stop");

            if(mAudioRecord == null) {
                mAudioRecord =  new AudioRecord(mAudioSource, mSampleRate, mChannelCount, mAudioFormat, mBufferSize);
                mAudioRecord.startRecording();
            }
            mRecordThread.start();
        }

    }

여기까지 수행 후 실행 시켜 보면 앱이 바로 죽는데, 로그를 확인해 보면 음성녹음을 위한 permission 이 없어서 AudioRecord 가 생성되지 못한 것을 알 수 있습니다.

11-28 20:06:31.467   770 14497 W ServiceManager: Permission failure: android.permission.RECORD_AUDIO from uid=10419 pid=-1
11-28 20:06:31.467   770 14497 E         : Request requires android.permission.RECORD_AUDIO
11-28 20:06:31.467   770 14497 E AudioFlinger: openRecord() permission denied: recording not allowed
11-28 20:06:31.472 31635 31635 E AndroidRuntime: java.lang.RuntimeException: Unable to start activity ComponentInfo{com.codetravel.audiorecord/com.codetravel.audiorecord.MainActivity}: java.lang.IllegalStateException: startRecording() called on an uninitialized AudioRecord.

음성녹음과 추후 파일 write 를 위해 아래 두개의 permission 을 AndroidManifest.xml 파일에 추가해 줍니다.

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

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

Record 버튼을 누르게 되면 녹음이 쭉 진행 되고, Stop 버튼을 누르면 /storage/emulated/0/ 위치 밑에 record.pcm 이름으로 녹음된 파일이 저장 된 것을 확인 할 수 있습니다.

4. 녹음 완료 -  생성된 파일 재생하기

생성된 파일을 재생하기 위해 AudioTrack 을 사용해 보도록 하겠습니다.

AudioTrack 도 AudioRecord 와 마찬가지로 PCM Audio Data 를 다룰 수 있는 API 중에 하나입니다.

AudioTrack 의 생성자는 AudioRecord class 의 생성자와 비슷한 형태를 띄기 때문에, 각 매개변수는 어렵지 않게 채울 수 있습니다.

- AudioTrack(int streamType, int sampleRateInHz, int channelConfig, int audioFormat, int bufferSizeInBytes, int mode) 

첫번째 매개변수인 streamtype 은 하기 링크에 정의되어 있는 stream type 중, 용도에 맞는 Stream type 값을 넣어주면 됩니다. (Music/Alarm/Voice call 등)

http://androidxref.com/8.0.0_r4/xref/frameworks/base/media/java/android/media/AudioManager.java#319

AudioRecord Class 에서 PCM Data 를 읽어오기 위해 read 함수를 이용했다면, 이번에는 write 함수를 이용해 Track 에 PCM Data 를 써주어서 스피커로 송출 될 수 있도록 하겠습니다.

파일에서 PCM Data 를 읽어와 Track 에 쓰기 위한 별도의 Thread 인 mPlayThread 를 onCreate 함수 내부에 정의 하였습니다.

mPlayThread 는 FileInputStream 을 이용해서 File 의 내용을 읽어다가 AudioTrack 에 write 해주는 역할을 합니다.

   
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ..
        mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, mSampleRate, mChannelCount, mAudioFormat, mBufferSize, AudioTrack.MODE_STREAM); // AudioTrack 생성
        ..
        mPlayThread = new Thread(new Runnable() {
            @Override
            public void run() {
                byte[] writeData = new byte[mBufferSize];
                FileInputStream fis = null;
                try {
                    fis = new FileInputStream(mFilePath);
                }catch (FileNotFoundException e) {
                    e.printStackTrace();
                }

                DataInputStream dis = new DataInputStream(fis);
                mAudioTrack.play();  // write 하기 전에 play 를 먼저 수행해 주어야 함

                while(isPlaying) {
                    try {
                        int ret = dis.read(writeData, 0, mBufferSize);
                        if (ret <= 0) {
                            (MainActivity.this).runOnUiThread(new Runnable() { // UI 컨트롤을 위해 
                                @Override
                                public void run() {
                                    isPlaying = false;
                                    mBtPlay.setText("Play");
                                }
                            });
                            break;
                        }
                        mAudioTrack.write(writeData, 0, ret); // AudioTrack 에 write 를 하면 스피커로 송출됨
                    }catch (IOException e) {
                        e.printStackTrace();
                    }

                }
                mAudioTrack.stop();
                mAudioTrack.release();
                mAudioTrack = null;

                try {
                    dis.close();
                    fis.close();
                }catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    public void onPlay(View view) {
        if(isPlaying == true) {
            isPlaying = false;
            mBtPlay.setText("Play");
        }
        else {
            isPlaying = true;
            mBtPlay.setText("Stop");

            if(mAudioTrack == null) {
                mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, mSampleRate, mChannelCount, mAudioFormat, mBufferSize, AudioTrack.MODE_STREAM);
            }
            mPlayThread.start();
        }

    }

아직 많은 예외처리들이 필요하지만 , 여기까지 하면 아주 아~주 간단한 Recorder 와 Player 가 완성 되었습니다. ^^

전체 코드 첨부하니 필요하신 분들은 참고하세요.

AudioRecord.zip