예나아빠_개발

git 지옥에서 온 git

터미널 또는 gitbash 툴을 사용하여 명령어를 이용해 소스를 관리

@start a working area(작업공간 시작하기.)

프로젝트 폴더 생성 후 폴더 안에서 

git init 하면 저장소가 생성이 되고 .git/ 폴더가 생성된다. 

.git 폴더는 버전 정보를 가지고 있다.

@git 이 관리할 파일 등록

생성된 파일 test.txt 가 있으면

터미널에서 git add test.txt 하면 등록이 된다

  add  

대상 파일을 git에게 추적하도록 명령하고 commit되기 전 stage에 등록한다. 

폴더의 상태를 확인할때는  git status 치면 된다.

@git 버전 만들기

git 버전을 만든 사람에 대한 정보를 설정한다.(한번만 설정하면 된다.)

git config --global user.name nickname

git config --global user.email email

git commit 하면

add 한 파일들에 대하여 파일의 상세설명을 등록하면

add한 파일들이 새로운 버전을 생성하게 된다.

text.txt 를 수정하였을 경우

등록때와 마찬가지로 파일을 수정하여 버전을 만들기 전에도 add 명령어를 사용한다.

git add text.txt 를 하여 수정된 파일을 다시 등록한다.

git commit 하면 새로운 버전을 등록 시 상세설명을 등록하여\

버전을 업데이트 해준다.

@git commit 전에 add를 해야하는 이유.

(git은 commit 전에 add를 꼭해야 합니다. 그 이유는 선택적으로 파일을 버전에 포함시키기 위해서 입니다.

여기서는 이에 대한 설명을 합니다.)

선택적 commit를 하기위해 add로 commit 할 파일만 등록한다.

stage area 커밋 대기 지역 

@ 변경사항 확인

git log -p  

:로그에서 출력되는 버전간의 차이점을 출력하고 싶을때

git diff '버전id' '버전id2'

:버전간의 차이점을 비교할때

git diff

:add 하기전과 add 한 후의 파일내용을 비교할때.

@ 버전 되돌리기

아래 명령은 버전 id로 돌아가는 명령입니다. 

git reset --hard "버전 id" 

버전 id의 커밋을 취소한 내용을 새로운 버전으로 만드는 명령

git revert "버전 id"

@git branch(작업 분기 하기)

매인 되는 작업과 테스트 되는 작업을 분리하여 매인 작업에 문제가 없도록 하기 위한 일

브랜치의 목록을 볼 때

git branch

브랜치를 생성할 때 

git branch "새로운 브랜치 이름"

브랜치를 삭제할 때

git branch -d

병합하지 않은 브랜치를 강제 삭제할 때 

git branch -D

브랜치를 전환(체크아웃)할 때

git checkout "전환하려는 브랜치 이름"

브랜치를 생성하고 전환까지 할 때 

git checkout -b "생성하고 전환할 브랜치 이름"

@브런치 

매인 브런치가 골조로 서브 브런치를 생성하여 매인 브런치는 영향이 없도록 브런치를 만들어 

서브 브런치에서 작업을 함.

서브 브런치에서 작업을 하고 push를 하면 원격 저장소 서브 브런치에 업로드가 됨.

새로운 브런치 생성.

git checkout -b newBranch

브런치 이동 

git checkout branch

브런치 삭제

git branch -d branch

@저장소 받아오기

로컬 저장소 복제 

git clone /로컬/저장소/경로

원격 저장소 복제

git clone 사용자명@호스트:/원격/저장소/경로 

@원격저장소

소스코드 백업

다른 사람들과의 협업

인터넷 연결하여 외부 저장소를 활용.

원격저장소로 소스를 복사하기

git remote add origin <원격서버 주소>

원격저장소로 변경 내용 업로드

git push origin 브런치

브런치 원격저장소로 전송.

git push origin branch

저장소 갱신(로컬 저장소를 원격 저장소에 맞춰 갱신)

git pull

브런치 병합

git merge branch

git 은 버전관리 시스템 이다.

git은 내 로컬 저장소 또는 원격 저장소에 저장할 수 있고 협업이 가능하다.

맨처음 파일 생성하면 add(버전관리) 할지 선택하고

소스를 완성하면 commit하여 버전관리를 함. 

소스의 설명 또는 버전 메시지를 넣을 수 있음.

(여기까지가 내 저장소에서 소스관리 하는 것..)

브런치.(원격 혹은 내 저장소에서 매인 소스를 건드리지 않고 소스를 관리하도록 함.)

매인 브런치가 골조로 서브 브런치를 생성하여 매인 브런치는 영향이 없도록 브런치를 만들어 

서브 브런치에서 작업을 함.

서브 브런치에서 작업을 하고 push를 하면 원격 저장소 서브 브런치에 업로드가 됨.

레트로핏 사용방법.

사용하는 방법은 대충 알겄는디 ??? 

정작 글로 쓸려고하니 뭔가 막히는 구문이 있다.

안드로이드에서 사용되는 여러 다양한 통신 기법 중 많이 사용되고 있는 레트로핏 통신방법

먼저 프로젝트를 생성한 다음 앱 그래들에 모듈을 포함시켜 준다.

GRADLE

//레트로핏 

implementation 'com.squareup.retrofit2:retrofit:2.4.0'

// 레트로핏 gson converter

implementation 'com.squareup.retrofit2:converter-gson:2.4.0'

// gson

implementation 'com.google.code.gson:gson:2.8.2'

//okhttp 로그 인터셉터

implementation 'com.squareup.okhttp3:logging-interceptor:3.10.0'

퍼미션에서 인터넷 권한을 준다.

//여기에 접속해서 필요한 데이터를 가져온다.

https://api.github.com/users/bearkinf

gson으로 데이터받을 클래스 생성.

/**유저 정보 관련 데이터 클래스*/

public class GithubUser {

    private String login;

    private String id;

    private String url;

    private String name;

    public String getLogin() {

        return login;

    }

    public void setLogin(String login) {

        this.login = login;

    }

    public String getId() {

        return id;

    }

    public void setId(String id) {

        this.id = id;

    }

    public String getUrl() {

        return url;

    }

    public void setUrl(String url) {

        this.url = url;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

/**저장소 관련 데이터 클래스.*/

public class GithubRepos {

    private String name;

    private String full_name;

    private String html_url;

    public String getName() { return name;  }

    public void setName(String name) {

        this.name = name;

    }

    public String getFull_name() {

        return full_name;

    }

    public void setFull_name(String full_name) {

        this.full_name = full_name;

    }

    public String getHtml_url() {

        return html_url;

    }

    public void setHtml_url(String html_url) {

        this.html_url = html_url;

    }

}

접속하기 위한 인터페이스를 만들고

public interface GithubConnectService {

    @GET("/users/{user}")

    Call<List<GithubUser>> getUser(@Path("user") String user);

    @GET("/users/{user}/repos")

    Call<List<GithubRepos>> getUserRepos(@Path("user") String user);

}

인터페이스르 사용하여 접속할 클래스 메서드를 만든다.

public class GithubConnectionApi {

    /**connection interface 리턴받음*/

    public static GithubConnectService setConnect() {

        OkHttpClient okHttpClient = new OkHttpClient.Builder()

                //통신시 request 및 response 상태 표시

                .addInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY))

                .build();

        return new Retrofit.Builder()

                .baseUrl("https://api.github.com/")

                // gson 데이터 파싱 메서드

                .addConverterFactory(GsonConverterFactory.create())

                // 통신 클라이언트 지정

                .client(okHttpClient)

                .build()

                // 통신 인터페이스 등록

                .create(GithubConnectService.class);

    }

}

MainActivity에서 통신 할 방법을 구현 한다.

public class MainActivity extends AppCompatActivity {

    Button button;

    TextView textview;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        textview = findViewById(R.id.textview);

        button = findViewById(R.id.button);

        button.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                Log.d("bear", "버튼 클릭");

                Call<GithubUser> githubUserCall = GithubConnectionApi.setConnect().getUser("bearkinf");

                githubUserCall.enqueue(new Callback<GithubUser>() {

                    @Override

                    public void onResponse(Call<GithubUser> call, Response<GithubUser> response) {

                        Log.w("bear", "response : " + response.body());

                        GithubUser user = response.body();

                        Log.w("bear", "getId : " + user.getId());

                        Log.w("bear", "getLogin : " + user.getLogin());

                        Log.w("bear", "getName : " + user.getName());

                        Log.w("bear", "getUrl : " + user.getUrl());

                    }

                    @Override

                    public void onFailure(Call<GithubUser> call, Throwable t) {

                        t.printStackTrace();

                    }

                });

            }

        });

    }

}

안드로이드 4.4.4버전에서 ssl 관련 통신 에러 발생함.

apply 사용

apply()는

apply()함수를 호출하는 객체를 이어지는 블록의 리시버{블록 안에 메서드 및 속성에 바로 접근할 수 있도록 할 객체}

로 전달하고, 객체 자체를 반환

    val people01 = People().apply {

        //this: People        

        // People 객체를 넘겨주고 속성을 초기화 한 후 people01 변수에 값을 넣어준다.

        name = "ppppp"

        age = 20

    }

//run 사용법.    

    people01.run {

        println("${people01.afterAge(age!!)}")

    }

apply 를 사용하지 않는 동일한 코드는 다음과 같다.

    val people02 = People()

    people02.name = "ppp02"

    people02.age = 21

//data class 

//class

data class People(var name: String? = null,

                  var age: Int? = null) {

    var doubleAge: Int? = null

}

let 사용

let()는

let() 함수를 호출하는 객체를 인자로 받아서 넘기고 블록의 결과값을 리턴해준다.

  val people01 = People().apply {

        //this: People        

        name = "ppppp"

        age = 20

// age = 20     

    }

    //억지스럽지만 이렇게도 된다.

    people01.doubleAge = people01.age?.let { it + it }

let 함수

fun main(args: Array<String>) {

    // 코틀린 let 함수

    // public inline fun <T, R> T.let(block: (T) -> R): R

    // T 를 인자로 받아서 블록안에 넘기고 (뭔가 작업을 하고)블록의 결과값 R을 리턴해줍니다.

    // 어떤 변수 또는 리턴값이 있는 메서드에서 let함수를 호출 하면

    // 호출한 변수값이나 메서드값을 {(블록)}의 인자로 넘기고

    // {} 안에 결과값을 반환한다.(retrun)

    // RxJava에서 map 함수와 비슷한 기능이랄까???

    var number100 = 100

    number100.let { it ->

        //필요에 위해 가공을 한다면 

        val returnCount = it + it

        //이렇게 값을 반환할 수 있다.

        return@let returnCount

    }

    // let 함수의 리턴받을 변수가 없기에 number100 은 아무 변화가 없다.

    println("number100 = $number100")

    //let 함수를 호출하면 

    number100 = number100.let { it ->

        //필요에 위해 가공을 한다면 

        val returnCount = it + it

        //이렇게 값을 반환할 수 있다.

        return@let returnCount

    }

    // number100 에 let 함수에서 받은 반환걊을 받아 값이 변하였다.

    println("number100 = $number100")

    //위 값에선 변화가 없지만.

    // 새로운 변수를 지정하고 let 함수를 리턴 받으면. 

    // 앞에서 number100은 200이 되었다.

    val number200 = number100.let { it ->

        val returnCount = it + it

        return@let returnCount

    }

    println("number200 = $number200")

    // 예제.

    fun doubleCount(count: Int): Int {

        return count * count

    }

    val data = doubleCount(2).let {

        // doubleCount 값 2*2를 인자로 받아서 

        // 4

        return@let it + it

        // 4+4 하고

        // val returnData = it + it

        // 그값을 리턴한다.

        // returnData

    }

    println("$data")

}

추상 클래스를 이용한 액티비티 구현 2-1.

2-2에서 퍼미션 권한 이용.

안드로이드 스튜디오 프로잭트 생성.

생성된 기본 액티비티.

MainActivity.java

//////////////////////////////////////////////////////////////////////////////////////////

public class MainActivity extends AppCompatActivity {

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

    }

}

//////////////////////////////////////////////////////////////////////////////////////////

추상 클래스 BaseActivity 생성.

BaseActivity.java

//////////////////////////////////////////////////////////////////////////////////////////

abstract class BaseActivity extends AppCompatActivity {

    /**상속받은 곳에서 xml 레이아웃을 받아옴.*/

    abstract int setLayout();

    @Override

    protected void onCreate(@Nullable Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(setLayout());

    }

}

//////////////////////////////////////////////////////////////////////////////////////////

생성된 BaseActivity를 MainActivity에서 상속받음.

MainActivity.java

//////////////////////////////////////////////////////////////////////////////////////////

public class MainActivity extends BaseActivity {

    @Override

    int setLayout() {

        // BaseActivit에서 만들어 놓은 추상 메서그 구현.

        // setContentView(R.layout.activity_main);

        // 추상메서드로 구현.

        return R.layout.activity_main;

    }

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

    }

}

//////////////////////////////////////////////////////////////////////////////////////////

이렇게 작업 한 이유는 액티비티를 상속 받은 처리 중 퍼미션 사용시 필요한 클래스 들을 정의 하여 사용하기 위함.

구현이 필요 없을 시엔 기존에 사용하던 대로 사용 가능.

MVP 패턴.

MODEL : 데이터 처리.

VIEW : 뷰 

PRESENT : MODEL과 VIEW 사이의 매개체

MVP 패턴의 동작

VIEW 에서 사용자 이벤트 수신

VIEW 에서 PRESENTER 이벤트 호출

PRESENTER 에서 MODEL 데이터 요청

MODEL 에서 PRESENTER 로 데이터 전달

PRESENTER 에서 전달받은 데이털 처리 후 VIEW 업데이트 요청

VIEW 에서 화면 업데이트

구현 방법

interface Contact

inner interface View

inner interface Present 

View 에서 처리할 이벤트 선언

Present 에서 처리할 이벤트 선언

View를 상속받는 Activiry 구현

Present를 상속받는 Presenter 구현

Presenter 에서 Model로 데이터 요청.(통신을 통한 서버 데이터 요청)

Model 에서 Presenter 가 요청한 데이터를 전달 후 Presenter에서 데이터 가공 후 View에 업데이트 요청

View 로 가공된 데이터를 가지고 화면 업데이트. 

MainActivityContract

MainActivity  MainActivityContract.View 상속

MainActivityPresenter MainActivityContract.Present 상속

MainActivityDataAction Present에서 데이터 요청

코틀린으로 코드 구현.

/**

 * 액티비티 상속 클래스

 */

abstract class BaseActivity : AppCompatActivity() {

    /**레이아웃 뷰 추상화 등록*/

    protected abstract val layoutId: Int

    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        setContentView(layoutId)

    }

}

/**

 * mvp 계약자 정의

 */

interface MainActivityContract {

    /**

     * 단순 화면 처리

     * 액티비이에서 뷰 구현

     */

    interface View {

        /** 뷰에 프레젠터 등록.*/

        val presenter: Present

        fun buttonClickChangeUI(count: Int)

    }

    /**

     * 프레젠터 뷰와 모델의 데이터 처리

     * 프레젠터 클래스를 생성하여 인터페이스 구현.

     */

    interface Present {

        /**

         * 프레젠터에 뷰 등록

         *

         */

        var view: View?

        /** 전달받을 뷰를 등록함.*/

        fun attachView(view: View)

        /** 뷰 해제*/

        fun detachView()

        fun buttonClickCountUp(count: Int)

    }

}

/**

 * MainActivity

 * 

 */

class MainActivity : BaseActivity(), MainActivityContract.View {

    /**BaseActivity에서 상속받은 변수. */

    override val layoutId = R.layout.activity_main

    /**뷰에 지정한 프레젠터 등록.*/

    override val presenter: MainActivityContract.Present = MainActivityPresenter()

    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        presenter.attachView(this)

        buttonEvent()

    }

    fun buttonEvent() {

        button_Click.setOnClickListener(View.OnClickListener {

            Log.w("bear", "buttonclick")

            presenter.buttonClickCountUp(count)

        }

        )

    }

    var count = 0

    override fun buttonClickChangeUI(count: Int) {

        this.count = count

        textview.text = "${this.count}"

    }

}

/**

 * 데이터를 처리하는 프레젠터

 * 처리된 결과를 등록한 뷰에 전달.

 */

class MainActivityPresenter : MainActivityContract.Present {

    /**뷰 초기화*/

    override var view: MainActivityContract.View? = null

    /**뷰 지정.onCreate 에 등록*/

    override fun attachView(view: MainActivityContract.View) {

        this.view = view

    }

    /**뷰 해제*/

    override fun detachView() {

        this.view = null

    }

    override fun buttonClickCountUp(count: Int) {

        view?.buttonClickChangeUI(count + 1)

    }

}

이런식으로 사용이 가능하다.