예나아빠_개발

레트로핏 사용.(java)

안드로이드 프로젝트 생성.

gradle dependencies setting.

app gradle.

dependencies {

    // 인터넷 연결 http 프로토콜

    // https://square.github.io/retrofit/

    // okhttp 를 포함하고 있다.

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

    // https://github.com/square/retrofit/tree/master/retrofit-converters/gson

    // gson 라이브러리를 포함하고 있다.

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

    // http 통신시 로그 보기위한 것.

    // https://github.com/square/okhttp/tree/master/okhttp-logging-interceptor

    // okhttp 를 포함하고 있다.

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

}

레트로핏을 사용할 기본 조건은 되었고.

레트로핏으로 통신을 할수있는 인터페이스 연결할 클래스 생성.

레트로핏은 http api를 인터페이스 형태로 사용한다.

public class GithubUser {

    private String login;

    private String url;

    private String name;

    private String location;

    private String repos_url;

    public String getLogin() {

        return login;

    }

    public void setLogin(String login) {

        this.login = login;

    }

    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 String getLocation() {

        return location;

    }

    public void setLocation(String location) {

        this.location = location;

    }

    public String getRepos_url() {

        return repos_url;

    }

    public void setRepos_url(String repos_url) {

        this.repos_url = repos_url;

    }

    @Override

    public String toString() {

        return "login :" + login + ", url :" + url + ", name :" + name + ", location : " + location + ", repos_url :" + repos_url;

    }

}

public class GithubUserRepository {

    private String name;

    private String html_url;

    private String language;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getHtml_url() {

        return html_url;

    }

    public void setHtml_url(String html_url) {

        this.html_url = html_url;

    }

    public String getLanguage() {

        return language;

    }

    public void setLanguage(String language) {

        this.language = language;

    }

    @Override

    public String toString() {

        return "name : " + name + ", html_url : " + html_url + ", language : " + language;

    }

}

public interface GithubService {

    @GET("users/{user}")

    Call<GithubUser> getGithubUser(@Path("user") String userName);

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

    Call<List<GithubUserRepository>> getGithubUserRepository(@Path("user") String userName);

}

ApiConnection 클래스 생성.

실제 통신을 담당할 retrofit 객체를 생성한다.

public class ApiConnection {

    private Retrofit retrofit;

    private final String baseUrl = "https://api.github.com";

    /**

     * 생성자.

     */

    private ApiConnection() {

        OkHttpClient httpClient = new OkHttpClient.Builder()

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

                .build();

        this.retrofit = new Retrofit.Builder()

                .baseUrl(baseUrl)

                // 내려받는 데이터를 gson 형식으로 데이터 변환

                .addConverterFactory(GsonConverterFactory.create())

                .client(httpClient)

                .build();

    }

        /**

     * 2. 싱글턴 패턴 구현.

     */

    private static final ApiConnection INSTANCE = new ApiConnection();

    public static ApiConnection getInstance() {

        return INSTANCE;

    }

    /**

     * interface  리턴.

     */

    public GithubService getRetrofitService() {

        return retrofit.create(GithubService.class);

    }

}

    MainActivity 에서

    void connection_01() {

        Call<GithubUser> result = ApiConnection.getInstance().getRetrofitService().getGithubUser("bearkinf");

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

            @Override

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

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

            }

            @Override

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

            }

        });

    }

oncreate()에서 함수를 호출하면 깃허브에서 내용을 가져온다.

레트로핏을 이용한 통신 프로젝트에 RxJava 넣기..

라이브러리 추가.

dependencies {

    implementation fileTree(include: ['*.jar'], dir: 'libs')

    implementation 'com.android.support:appcompat-v7:28.0.0'

    implementation 'com.android.support.constraint:constraint-layout:1.1.3'

    implementation 'com.android.support:support-v4:28.0.0'

    testImplementation 'junit:junit:4.12'

    androidTestImplementation 'com.android.support.test:runner:1.0.2'

    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'

    //로그켓 .

    implementation 'com.github.bearkinf:AndroidLogPrintUtil_Java:1.1.1'

    // 인터페이스를 통해 인터넷 연결을 가지고 있다.

    // https://square.github.io/retrofit/

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

    // https://github.com/square/retrofit/tree/master/retrofit-converters/gson

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

    // http 통신시 로그 보기위한 것.

    // https://github.com/square/okhttp/tree/master/okhttp-logging-interceptor

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

    // Rxjava 타입을 지원한다.

    // https://github.com/square/retrofit/tree/master/retrofit-adapters/rxjava2

    // 자체적으로 RxJava 라이브러리를 가지고 있다.(최신 버전은 아님.)

    // adapter-rxjava2 내부적으로 rxjava를 참조하나, 버그가 수정된 최신버전의 rxjava를 명확히 정의하여 해당 library를 사용하게 하도록한다.

    implementation 'com.squareup.retrofit2:adapter-rxjava2:2.5.0'

    // https://github.com/ReactiveX/RxJava

    // 각각의 라이브러리가 RxJava를 참조하나 최신 라이브러리를 지정한다.

    // rxandroid 내부적으로 rxjava를 참조하나, 버그가 수정된 최신버전의 rxjava를 명확히 정의하여 해당 library를 사용하게 하도록한다.

    implementation "io.reactivex.rxjava2:rxjava:2.2.6"

    // https://github.com/ReactiveX/RxAndroid 스케줄러 관리 (쓰레드 관리

    // 자체적으로 RxJava 라이브러리를 가지고 있다.(최신 버전은 아님.)

    implementation 'io.reactivex.rxjava2:rxandroid:2.1.0'

}

레트로핏 인터페이스에 RxJava 추가.

public interface GithubService {

    @GET("users/{user}")

    Call<GithubUser> getGithubUser(@Path("user") String userName);

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

    Call<List<GithubUserRepository>> getGithubUserRepository(@Path("user") String userName);

    //RxJava 용 .Observable

    @GET("users/{user}")

    Observable<GithubUser> getGithubUser2(@Path("user") String userName);

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

    Flowable<List<GithubUserRepository>> getGithubUserRepository2(@Path("user") String userName);

}

레트로핏 객체에 RxJava 를 사용하기 위해 아답터 추가.

public class ApiConnection {

    private Retrofit retrofit;

    private final String baseUrl = "https://api.github.com";

    /**

     * 생성자.

     */

    private ApiConnection() {

        OkHttpClient httpClient = new OkHttpClient.Builder()

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

                .build();

        this.retrofit = new Retrofit.Builder()

                .baseUrl(baseUrl)

                // 내려받는 데이터를 gson 형식으로 데이터 변환

                .addConverterFactory(GsonConverterFactory.create())

                // RxJava 를 사용하게되면 해당 아답터팩토리를 등록해야 한다.

                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())

                .client(httpClient)

                .build();

    }

        /**

     * 2. 싱글턴 패턴 구현.

     */

    private static final ApiConnection INSTANCE = new ApiConnection();

    public static ApiConnection getInstance() {

        return INSTANCE;

    }

    /**

     * interface  리턴.

     */

    public GithubService getRetrofitService() {

        return retrofit.create(GithubService.class);

    }

}

MainActivity에서 RxJava를 이용한 레트로핏 통신 코드 넣기.

    void connection_03() {

        /**

         * 람다식으로 사용을하려면 .

         *   compileOptions {

         *         sourceCompatibility JavaVersion.VERSION_1_8

         *         targetCompatibility JavaVersion.VERSION_1_8

         *   }

         *   넣어 주어야 한다.

         */

        LogPrintUtil.w("connection_03 start");

        ApiConnection.getInstance().getRetrofitService()

                .getGithubUser2("bearkinf")

                .subscribeOn(Schedulers.io())

                .observeOn(AndroidSchedulers.mainThread())

                .subscribe(githubUser -> {

                            LogPrintUtil.w("Observable    Data :" + githubUser);

                        }, throwable -> {

                        }

                );

    }

oncreate()에서 함수를 호출하면 깃허브에서 내용을 가져온다.

코틀린 버전은 코틀린 탭에서. 다시 작성.

코틀린 프로잭트 생성.

레트로핏 인터페이스 생성.

interface GithubService {

    @GET("users/{user}")

    fun getGithubUser(@Path("user") userName: String): Call<GithubUser>

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

    fun getgithubUserRepository(@Path("user") userName: String): Observable<List<GithubUserRepository>>

}

레트로핏 객체 클래스 생성.

/**스테틱 클래스 생성.*/

object ApiConnection {

    private val BASE_URL = "https://api.gitHub.com"

    private val retrofit by lazy {

        val httpClient = OkHttpClient.Builder()

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

            .build()

        Retrofit.Builder()

            .baseUrl(BASE_URL)

            .addConverterFactory(GsonConverterFactory.create())

            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())

            .client(httpClient)

            .build()

    }

    val getRetrofitService = retrofit.create(GithubService::class.java)

}

MainActivity 에서 oncreate 에 함수 적용.

    private fun retrofitConnection_01() {

        val getGithubUser = ApiConnection.getRetrofitService.getGithubUser("bearkinf")

        getGithubUser.enqueue(object : Callback<GithubUser> {

            override fun onFailure(call: Call<GithubUser>, t: Throwable) {

            }

            override fun onResponse(call: Call<GithubUser>, response: Response<GithubUser>) {

                LogPrintUtil.w("response : ${response.body()}")

            }

        })

    }

    private fun retrofitConnection_02() {

        ApiConnection.getRetrofitService

            .getgithubUserRepository("bearkinf")

            .subscribeOn(Schedulers.io())

            .observeOn(AndroidSchedulers.mainThread())

            .subscribe({

                LogPrintUtil.w("RxJava : $it")

            }, {

            })

    }

코틀린 isNullOrBlank or isNullOrEmpty 테스트.

// 널 을 가지고 있는 스트링.
var nullString: String? = null

//공백체크.
println(nullString.isNullOrBlank()?.toString())  //output: true
//비어있는
println(nullString.isNullOrEmpty()?.toString())  //output: true

// 데이터를 가지고 잇는 스트링.
var helloString: String = "Hello"
println(helloString.isNullOrBlank()?.toString())  //output: false
println(helloString.isNullOrEmpty()?.toString())  //output: false

// 빈 문자열을 가지고 있는 스트링.
var blankString: String = ""
println(blankString.isNullOrBlank()?.toString())  //output: true
println(blankString.isNullOrEmpty()?.toString())  //output: true

// 공백을 가지고 있는 스트링.
var emptyString: String = "      "
println(emptyString.isNullOrBlank()?.toString())  //output: true
println(emptyString.isNullOrEmpty()?.toString())  //output: false

// 공백을 가지고 있는 스트링.
var emptyString2: String = " ㅇㅇㅇ"
println(emptyString2.isNullOrBlank()?.toString())  //output: false
println(emptyString2.isNullOrEmpty()?.toString())  //output: false

안드로이드 추상 클래스 이용한 퍼미션 권한 설정. 2-2

에서 만든 java 소스를 코틀린으로 변환 수정

BaseActivity.kt 

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

abstract class BaseActivity : AppCompatActivity() {

    abstract val setLayout: Int

    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        setContentView(setLayout)

    }

    private val PERMISSION_REQUEST: Int = 1000

    /**인터페이스 등록.*/

    interface PermissionCheckListener {

        fun permissionCheckFinish()

    }

    /**클래스 내 사용할 퍼미션 체크 리스너 (setter 구현 방법이 특이함.)

     * 온 크레딧 바로 아래 생성 되어야 한다

     * */

    lateinit var permissionCheckListener: PermissionCheckListener

    /**

     * 스트링 배열로 퍼미션 체크.

     */

    fun permissionCheck(strings: Array<String>): Boolean {

        // 변수 사용시 리턴 타입 지정.

        // var check = false

        // 변수 사용안하고 바로 리턴시켜 버림.

        //안드로이드 마시멜로 이후 퍼미션 체크.

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {

            for (i in 0 until strings.size) {

                if (ContextCompat.checkSelfPermission(this, strings[i]) == PackageManager.PERMISSION_DENIED) {

                    ActivityCompat.requestPermissions(this, strings, PERMISSION_REQUEST)

                    // check = true

                    // break

                    return true

                }

            }

        }

        //return check

        return false

    }

    /**

     * 거부를 했을때 처리

     * 다시보지 않기 체크 후 거부를 하면 설정에서 권한을 허용하도록 요청.

     * 허용하지 않을 경우 앱 사용 을 못함..

     * 처리를 잘못하면 무한 반복할 경우가 생김.

     */

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {

        super.onRequestPermissionsResult(requestCode, permissions, grantResults)

        if (requestCode == PERMISSION_REQUEST) {

            //안드로이드 마시멜로 이후 퍼미션 체크.

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {

                for (i in grantResults.indices) {

                    if (grantResults[i] == 0) {

                        if (grantResults.size == i + 1) {

                            permissionCheckListener?.permissionCheckFinish()

                        }

                    } else {

                        // 거부한 이력이 있으면 true를 반환한다.

                        if (shouldShowRequestPermissionRationale(permissions[i])) {

                            ActivityCompat.requestPermissions(this, permissions, PERMISSION_REQUEST)

                        } else {

                           AlertDialog.Builder(this)

                                .setTitle("다시보지않기 클릭.")

                                .setMessage(permissions[i] + " 권한이 거부되었습니다 설정에서 직접 권한을 허용 해주세요.")

                                .setNeutralButton("설정") { dialog, which ->

                                    val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)

                                    intent.data = Uri.parse("package:$packageName")

                                    startActivity(intent)

                                    Toast.makeText(applicationContext, "권한 설정 후 다시 실행 해주세요.", Toast.LENGTH_SHORT).show()

                                    finish()

                                }

                                .setPositiveButton("확인") { dialog, which ->

                                    Toast.makeText(applicationContext, "권한 설정을 하셔야 앱을 사용할 수 있습니다.", Toast.LENGTH_SHORT)

                                        .show()

                                    finish()

                                }

                                .setCancelable(false)

                                .create().show()

                        }// shouldShowRequestPermissionRationale /else

                    } // 권한 거절

                } // for end

            }//Build.VERSION.SDK_INT  end

        }//requestCode  end

    }

}

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

MainActivity에서 사용 방법.

Manifest에 

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

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

퍼미션 등록 확인.

MainActivity.kt

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

class MainActivity : BaseActivity() {

    override val setLayout = R.layout.activity_main

    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        permissionCheckListener = object : PermissionCheckListener {

            override fun permissionCheckFinish() {

                Log.e("log", "start Activity")

            }

        }

        if (permissionCheck(arrayOf(Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE))) {

            return

        }

        permissionCheckListener?.permissionCheckFinish()

    }

}

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

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")

}