Jaybon 의 지식창고

안드로이드

docs.google.com/presentation/d/1pZrpTdI0uNpb6IY7csBPn61x_uISEcBZ5LSTWucNDS4/edit?usp=sharing

리액트

docs.google.com/presentation/d/1vdb4w_VAPLQjWyxdtM7Vhl1jZyrltCvffpyLf1BYcls/edit?usp=sharing

runOnUiThread

UI쓰레드 = 메인 쓰레드 (onCreate를 실행하는 쓰레드)

다운로드 받을 때에는 무조건 새로운 쓰레드(I/O)

새로운쓰레드로 다운로드 -> 쓰레드 마지막에 콜백

다운로드 다받은 데이터를 메인쓰레드의 변수에서 쓰기 어렵다(다운로드 받는 걸 메인에서 기다리지 않기 때문)

그래서 runOnUiThread 나 핸들러를 사용해야한다.

사용하지 않을려면

메인쓰레드에 함수에 넘겨야하는데 자바는 함수를 넘길 수 없으므로 클래스(인터페이스)를 넘겨야한다

asyncTask를 이용하여 메인에서 다운로드 데이터를 받는 타이밍을 잡아야한다

원리를 이해하고 나서 라이브러리를 사용하자

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

asyncTask

두잇 안드 490페이지 메서드(doInBackground)

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

메인쓰레드

이벤트핸들러 쓰레드

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

다른 쓰레드에서 이벤트핸들러쓰레드를 통해서 메인쓰레드의 이미지를 변경한다

어떻게 하면 다른 쓰레드가 이벤트핸들러에 접근할 수 있을까

1. 쓰레드 안에 runOnUiThread()를 하나더 만들어서 이용 - 핸들러에게 던짐

2. 핸들러를 이용하는 방법 handler.post() (Do it 안드 478페이지)

3.

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

프로그레스 진행 만들기

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

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">


    <ProgressBar
        android:id="@+id/progressBar"
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_weight="1" />

    <Button
        android:id="@+id/btn_execute"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="실행" />

    <Button
        android:id="@+id/btn_stop"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="중지" />


</LinearLayout>

MainActivity

package com.jaybon.asynctask;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;

public class MainActivity extends AppCompatActivity {

    private Button btnExecute, btnStop; //실행 중지버튼
    private ProgressBar progressBar; // 진행바
    private int value = 0; // 진행바의 퍼센테이지
    private Handler handler = new Handler();

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

        mInit(); // 함수 사용할 때 내가 만든 것은 m을 붙이고 오버라이딩은 그대로

        progressBar.setProgress(value);

        mListenser();

    }

    private void mListenser() {
        btnExecute.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                new Thread(new Runnable() { // 여기다가 데이터변환을 쓰면 안된다(runOnUiThread나 핸들러)
                    @Override
                    public void run() {
                        // runOnUiThread는 잘 안쓰니까 핸들러를 사용하자
                        handler.post(new Runnable() { // 핸들러한테 던지는 타겟을 넣기
                            @Override
                            public void run() {
                                while (true) {
                                    value = value + 5;
                                    progressBar.setProgress(value);
                                    try {
                                        Thread.sleep(500);
                                    } catch (InterruptedException e) {
                                        e.getStackTrace();
                                    }
                                    if(value >= 100){
                                        break;
                                    }
                                }
                            }
                        });
                    }
                }).start();
            }
        });
    }

    private void mInit() {
        btnExecute = findViewById(R.id.btn_execute);
        btnStop = findViewById(R.id.btn_stop);
        progressBar = findViewById(R.id.progressBar);
    }
}

결과

진행이 안되고 한번에 쫙 100퍼가 채워진다

쓰레드가 종료되야 핸들러가 실행되기 때문

데이터는 변경된다! 다만 UI에 그리는건 핸들러 쓰레드가 끝나야 되는 것!

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

asyncTask로 변경하여 만들기

블록지정 부분 삭제

제네릭 값이 전달된다

package com.jaybon.asynctask;

import androidx.appcompat.app.AppCompatActivity;

import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "Main_Activity";

    private Button btnExecute, btnStop; //실행 중지버튼
    private ProgressBar progressBar; // 진행바
    private int value = 0; // 진행바의 퍼센테이지
    private Handler handler = new Handler();

    class BackgroundTask extends AsyncTask<Integer, Integer, Integer> {  // 이것이 쓰레드가 됨

        @Override // 타겟 호출 직전
        protected void onPreExecute() {
            super.onPreExecute();
            progressBar.setProgress(value);
            Log.d(TAG, "onPreExecute: ");
        }

        @Override // 타겟 (run()과 같음)
        protected Integer doInBackground(Integer... integers) { // 스레드 실행시 인수 받기
            Log.d(TAG, "doInBackground: ");

            while (value < 100){

                value = value + 5;
                // 이 값은 onProgressUpdate로 넘어간다
                // 넘어가서 바로 그려짐
                publishProgress(value);

                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
            // 이 값이 onPostExecute의 매개변수로 넘어간다
            return 1; // 정상적으로 수행됐으면 1, 안됐으면 -1
        }

        @Override // UI쓰레드에 그림을 그려주는 메서드
        protected void onProgressUpdate(Integer... values) { // publishProgress 리턴 값 받기
            super.onProgressUpdate(values);
            Log.d(TAG, "onProgressUpdate: ");
            progressBar.setProgress(values[0]); // Integer...는 배열이라서 0번 주소 = Integer[]
        }

        @Override // 타겟 호출 이후
        protected void onPostExecute(Integer integer) { // doInBackground 리턴 값 받기
            // 리턴값 받아서 값에 따라 분기
            super.onPostExecute(integer);
            Log.d(TAG, "onPostExecute: ");
            Toast.makeText(MainActivity.this, "다운로드 완료", Toast.LENGTH_SHORT).show();
        }
    }

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

        mInit(); // 함수 사용할 때 내가 만든 것은 m을 붙이고 오버라이딩은 그대로

        mListenser();

        

    }

    private void mListenser() {

        btnExecute.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                new BackgroundTask().execute(); // execute(여기의 값이 doInBackground 의 매개변수로 감)

            }
        });

        btnStop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

            }
        });
    }

    private void mInit() {
        btnExecute = findViewById(R.id.btn_execute);
        btnStop = findViewById(R.id.btn_stop);
        progressBar = findViewById(R.id.progressBar);
    }
}

이렇게 짜면 중지 할 수 없다

중지하려면 전역변수로 잡아줘야한다

멈추기

멈추기는 가능하나 다시 실행이 안된다

중지 재시작

package com.jaybon.asynctask;

import androidx.appcompat.app.AppCompatActivity;

import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "Main_Activity";

    private Button btnExecute, btnStop; //실행 중지버튼
    private ProgressBar progressBar; // 진행바
    private int value = 0; // 진행바의 퍼센테이지
    private  BackgroundTask task;

    class BackgroundTask extends AsyncTask<Integer, Integer, Integer> {  // 이것이 쓰레드가 됨

        @Override // 타겟 호출 직전
        protected void onPreExecute() {
            super.onPreExecute();
            progressBar.setProgress(value);
            Log.d(TAG, "onPreExecute: ");
        }

        @Override // 타겟 (run()과 같음)
        protected Integer doInBackground(Integer... integers) { // 스레드 실행시 인수 받기
            Log.d(TAG, "doInBackground: ");

            while (isCancelled() == false){

                value = value + 5;

                if(value >= 100){
                    break;
                }

                // 이 값은 onProgressUpdate로 넘어간다
                // 넘어가서 바로 그려짐
                publishProgress(value);

                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
            // 이 값이 onPostExecute의 매개변수로 넘어간다
            return 1; // 정상적으로 수행됐으면 1, 안됐으면 -1
        }

        @Override // UI쓰레드에 그림을 그려주는 메서드
        protected void onProgressUpdate(Integer... values) { // publishProgress 리턴 값 받기
            super.onProgressUpdate(values);
            Log.d(TAG, "onProgressUpdate: ");
            progressBar.setProgress(values[0]); // Integer...는 배열이라서 0번 주소 = Integer[]
        }

        @Override // 타겟 호출 이후
        protected void onPostExecute(Integer integer) { // doInBackground 리턴 값 받기
            // 리턴값 받아서 값에 따라 분기
            super.onPostExecute(integer);
            Log.d(TAG, "onPostExecute: ");
            Toast.makeText(MainActivity.this, "다운로드 완료", Toast.LENGTH_SHORT).show();
        }
    }

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

        mInit(); // 함수 사용할 때 내가 만든 것은 m을 붙이고 오버라이딩은 그대로

        task = new BackgroundTask();

        mListenser();

    }

    private void mListenser() {

        btnExecute.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                if(task == null || task.isCancelled() == true){
                    task = new BackgroundTask();
                    task.execute(); // execute(여기의 값이 doInBackground 의 매개변수로 감)
                }


            }
        });

        btnStop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                task.cancel(true);


            }
        });
    }

    private void mInit() {
        btnExecute = findViewById(R.id.btn_execute);
        btnStop = findViewById(R.id.btn_stop);
        progressBar = findViewById(R.id.progressBar);
    }
}

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

쓰레드종료 interrupt()를 걸면된다. (무조건 sleep 주자)

task.cancel = 잠깐 멈춰서 interrupt()

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

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

플래그와 부가 데이터

액티비티는 [액티비티 매니저] 라는 객체에 의해 [액티비티 스택]이라는 것으로 관리됨

액티비티를 차곡차곡 쌓아두고 상위에 있는 액티비티가 없어지면 이전의 액티비티가 화면에 보임

순서

액티비티 생성

매니페스트 파일 등록

startActivity() 또는 startActivityForResult() 메서드를 사용해 실행

새로운 액티비티가 화면에 띄워짐

이전 액티비티는 액티비티 스택에 저장

액티비티가 없어지면 스택 최상위에 있는 액티비티가 노출

(동일한 액티비티를 여러번실행하면 스택에 계속 쌓여 데이터를 여러번 접근하거나 리소스 문제 발생)

NO_FLAG

FLAG_ACTIVITY-SINGLE-TOP

FLAG_ACTIVITY-NO_HISTORY

FLAG_ACTIVITY-CLEAR_TOP

NO_FLAG 일 경우 같은 액티비티가 계속 해서 쌓인다

FLAG_ACTIVITY-SINGLE-TOP 일 경우 같은 액티비티는 하나만 쌓인다

새로운 액티비티를 띄워주는 액티비티를 부모 액티비티라고 할경우

전달하는 인텐트는 새로 만들어진 인텐트의 onCreate()메서드 안에서 getIntent()메서드로 참조 할 수있다

onNewIntent()메서드를 재정의 하면 액티비티가 새로 만들어지지 않았을 때 인텐트 객체만 전달 받을 수 있음

액티비티가 이미 메모리에 객체로 만들어져 있다면 액티비티를 다시 띄우더라도 onCreate()가 실행되지 않기 때문에

onNewIntent()를 재정의 해서 사용해야한다

브로드캐스트 수신자?

FLAG_ACTIVITY-NO_HISTORY

항상 맨처음의 액티비티가 보이게된다 알림 메시지등 한번화면에 보여줄 때 좋음

FLAG_ACTIVITY-CLEAR_TOP

는 되돌아갈 때 스택에 상위 액티비티를 다 제거하고 메인 액티비티로 가게됨

부가데이터 

Intent Bundle

번들 객체는 해시테이블과 유사

기본자료형을 넣고 뺄수 있지만 Serializable 객체도 사용가능

안드로이드는 객체를 전달할때 Serializable 보다 Parcelable인터페이스 권장

---------

HTTP속성 - 레퍼럴 - 다이렉트로 접근시 레퍼럴 정보가 없으면 뜨지 않는 것

---------

롬복

저장소(리파지토리)추가

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

Intent

Intent를 간단히 생각하면

트럭이라고생각하면된다

출발지와 목적지를 알려주고 내용을 싣는다

번들객체 - 오브젝트를 싣는 곳

입력시  put을 사용한다

shift 따닥

바이트로 바꾼다! (직렬화)

메인액티비티

안드로이드 내부에서는 Bundle을 사용하면 된다

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

TASK - 액티비티가 쌓이는 것

기본적으로 페이지이동시 액티비티를 날리고(finish), 데이터를 남기고 싶을 경우에는 종료를 시키지 않는다

TASK 설정에 따라 같은 액티비티가 뜨면 이전의 액티비티를 날릴 수 있다

Static저장소

-----------

앱 오류시

clean Rebuild

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

LayoutInflater

레이아웃 = 뷰그룹 = 컨테이너

브로드캐스팅

들어오는 모든데이터 중에서 취사선택

모든 방송사의 데이터 중 하나를 걸러내는 것 (TV로 데이터가 다오는데 채널하나 선택)

(카카오톡 메시지 수신 + 카카오톡에서 문자메시지 수신 - 권한)

컨텍스트

애플리케이션 컨텍스트 - 앱 자체의 컨텍스트

액티비티 컨텍스트 - 액티비티의 컨텍스트

액티비티 매니저 서비스

안드로이드 OS

포그라운드 앱 - 선택했을 경우에만 뜸

서비스 앱 (백그라운드 앱) - 서비스는 데몬으로 돈다

일반OS는 프로그램을 실행시키면 프로세스가 된다

즉 각각 다 작동되고 있는 상태이다

안드로이드OS는 액티비티 매니저 서비스 라는 앱이 있고 이 것이 모든 앱들을 관리한다

즉 안드로이드는 프로세스가 하나다

다른 앱들을 켜면 액티비티 매니저 서비스에서 관리하게 된다

화면에 보이는 앱들은 작동되고 화면 뒤로 간 앱들은 중지상태가 된다
(중지상태가 된 앱들은 메모리자원을 적게 차지하고 앱의 정보만 들고 있게된다- 이것을 context라고 한다)

contextId

다른앱으로 전환하면 컨텍스트 스위칭이 일어난다

앱들끼리는 매니저를 통해서 통신할 수 있다

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

앱은 스스로 액티비티 컨텍스트를 관리한다

A1.this

getContext()

getApplicationContext()

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

안드로이드 생명주기

책 277

ctrl + o

앱을 처음 켜면

앱을 다시 선택하면

앱을 끄면

체류시간은 onStart부터 onRestart까지로 잡으면됨

중요

시작! - onCreate

정지 - onPause

다시돌아올때 - onResume

종료할때 - onDestroy

package com.jaybon.lifecycleex01;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.util.Log;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "Main_Activity";

    private String downloadData = ""; // 다운로드 데이터로 가정한다
    private String currentState = "";



    @Override
    protected void onStart() {
        super.onStart();
        Log.d(TAG, "onStart: ");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d(TAG, "onRestart: ");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d(TAG, "onStop: ");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "onPause: ");

        currentState = "에너지 50";
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume: ");

        Log.d(TAG, "onResume: 현재 에너지는 "+currentState);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy: ");
    }

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

        // 다운로드 시작
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for(int i=1; i<4; i++){
                        Thread.sleep(1000);
                        Log.d(TAG, "run: "+i+"초");
                    }
                    downloadData = "다운받은 데이터";
                    Log.d(TAG, "run:  다운로드 종료");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        Log.d(TAG, "onCreate: ");
    }
}

------

shared preferences

앱을꺼도 데이터를 남기고 싶을때 

shared preferences - 내부 하드디스크에 저장하는 기술

앱은 스스로의 shared preferences가 있다

이런 값을 public으로 저장했다면 다른앱에 데이터 공유할 수 있다

웹브라우저의 쿠키개념과 비슷하다

하지만 앱을 지우거나 휴대폰을 바꿀 때 사라지므로 DB에 데이터를 저장하는 것이 좋다

종료시 저장

시작시 가져오기

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

MainActivity

package com.jaybon.lifecycleex02;

import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;

import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "Main_Activity";

    //메인 액티비티의 전역변수, 걸어두고 사용하는 것이 편리하다
    //메인 액티비티의 모든 것이 담겨있다
    private Context mContext = MainActivity.this;

    private Button btnNum, btnEmail;
    private TextView tvNum, tvEmail;

    
    // 콜백함수
    // 어떤화면이 꺼지면 데이터값을 가져오는 것?
    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        Log.d(TAG, "onActivityResult: 콜백받음");
    }

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

        tvNum = findViewById(R.id.tv_num);
        tvEmail = findViewById(R.id.tv_email);
        btnEmail = findViewById(R.id.btn_email);
        btnNum = findViewById(R.id.btn_num);

        // 리스너
        btnNum.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 트럭 생성 getBaseContext() 또는 MainActivity.this 또는 전역변수로 등록하여 사용
                // 출발지 MainActivity.this, 목적지 Sub2Activity.class
                Intent intent = new Intent(mContext, SubActivity.class);

                // startActivity(intent); 이동만 할때 사용

                // 이동 및 응답을 받을 수 있는 것
                // 나를 띄운 페이지 확인 requestCode (enum 등을 사용하자)
                startActivityForResult(intent, 1);

            }
        });
        
        

    }
}

SubActivity

package com.jaybon.lifecycleex02;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class SubActivity extends AppCompatActivity {

    private Button btnSubNum;


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

        btnSubNum = findViewById(R.id.btn_sub_num); // 버튼이름을 같게 해도 충돌안남
        btnSubNum.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });
    }
}

Sub2Activity

package com.jaybon.lifecycleex02;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

public class Sub2Activity extends AppCompatActivity {

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

MainActivity

261 271

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

플래그와 부가 데이터

액티비티는 [액티비티 매니저] 라는 객체에 의해 [액티비티 스택]이라는 것으로 관리됨

액티비티를 차곡차곡 쌓아두고 상위에 있는 액티비티가 없어지면 이전의 액티비티가 화면에 보임

순서

액티비티 생성

매니페스트 파일 등록

startActivity() 또는 startActivityForResult() 메서드를 사용해 실행

새로운 액티비티가 화면에 띄워짐

이전 액티비티는 액티비티 스택에 저장

액티비티가 없어지면 스택 최상위에 있는 액티비티가 노출

(동일한 액티비티를 여러번실행하면 스택에 계속 쌓여 데이터를 여러번 접근하거나 리소스 문제 발생)

NO_FLAG

FLAG_ACTIVITY-SINGLE-TOP

FLAG_ACTIVITY-NO_HISTORY

FLAG_ACTIVITY-CLEAR_TOP

NO_FLAG 일 경우 같은 액티비티가 계속 해서 쌓인다

FLAG_ACTIVITY-SINGLE-TOP 일 경우 같은 액티비티는 하나만 쌓인다

새로운 액티비티를 띄워주는 액티비티를 부모 액티비티라고 할경우

전달하는 인텐트는 새로 만들어진 인텐트의 onCreate()메서드 안에서 getIntent()메서드로 참조 할 수있다

onNewIntent()메서드를 재정의 하면 액티비티가 새로 만들어지지 않았을 때 인텐트 객체만 전달 받을 수 있음

액티비티가 이미 메모리에 객체로 만들어져 있다면 액티비티를 다시 띄우더라도 onCreate()가 실행되지 않기 때문에

onNewIntent()를 재정의 해서 사용해야한다

브로드캐스트 수신자?

FLAG_ACTIVITY-NO_HISTORY

항상 맨처음의 액티비티가 보이게된다 알림 메시지등 한번화면에 보여줄 때 좋음

FLAG_ACTIVITY-CLEAR_TOP

는 되돌아갈 때 스택에 상위 액티비티를 다 제거하고 메인 액티비티로 가게됨

부가데이터 

Intent Bundle

번들 객체는 해시테이블과 유사

기본자료형을 넣고 뺄수 있지만 Serializable 객체도 사용가능

안드로이드는 객체를 전달할때 Serializable 보다 Parcelable인터페이스 권장