BelieveCom

지난 시간에 카메라를 사용해서 이미지 뷰에 연결하는 방법을 공부했습니다.

카메라 캡처를 사용해서 이미지를 사용하면 해상도가 떨어지기 때문에 원본이 손실되는 문제가 발생했습니다.

이번 시간에는 원본 이미지 손실을 최소화할 수 있는 이미지 저장 방법에 대해서 알아보겠습니다.

지난 시간에 배운 코틀린을 이용한 카메라 이미지 저장 실행 화면입니다.

원본 이미지 해상도가 많이 떨어지는 것을 확인할 수 있습니다.

해상도를 유지하기 위해서 먼저 촬영된 이미지를 원본 그대로 갤러리에 저장 후 로드하는 형태로 변경해보겠습니다.

카메라 원보 이미지를 저장하기 위해서 먼저 이미지 경로 Uri를 생성합니다.

fun createImageUri(filename:String, mimeType:String):Uri?{
        var values = ContentValues()
        values.put(MediaStore.Images.Media.DISPLAY_NAME,filename)
        values.put(MediaStore.Images.Media.MIME_TYPE, mimeType)
        return contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)
    }

ContentValues를 사용해서 이미지 Uri를 생성합니다.

contentResolver는 contentProvider과 비즈니스 로직의 중계자 역할을 담당합니다.

ContentValues는 contentResolver이 사용하는 데이터 정보라고 생각하면 됩니다.

ContentValues에 이미지 이름과 타입을 저장합니다.

카메라를 동작하기 위해서 dispatchTakePictureIntentEx 함수를 추가합니다.

private var photoURI : Uri? = null
    private val REQUEST_CREATE_EX = 3

    private fun dispatchTakePictureIntentEx()
    {
        val timeStamp: String = SimpleDateFormat("yyyyMMdd_HHmmss").format(Date())
        val storageDir: File? = getExternalFilesDir(Environment.DIRECTORY_PICTURES)
        val takePictureIntent : Intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
        val uri : Uri? =   createImageUri("JPEG_${timeStamp}_", "image/jpg")
        photoURI = uri
        takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, photoURI)
        startActivityForResult(takePictureIntent, REQUEST_CREATE_EX)
    }

전역 경로 photoURI, 이벤트 ID REQUEST_CREATE_EX를 선언합니다.

이전 시간에 선언한 함수와 동일하 구성이기 때문에 Ex를 붙여서 이름을 변경했습니다.

timeStamp를 사용해서 이미지 이름을 시간에 따라서 생성합니다.

CreateimageUri 함수를 호출해서 이미지를 생성하고 카메라를 실행합니다.

fun loadBitmapFromMediaStoreBy(photoUri: Uri) : Bitmap?{
        var image: Bitmap? = null
        try{
            image = if(Build.VERSION.SDK_INT > 27){
                val source: ImageDecoder.Source =
                    ImageDecoder.createSource(this.contentResolver, photoUri)
                ImageDecoder.decodeBitmap(source)

            }else{
                MediaStore.Images.Media.getBitmap(this.contentResolver, photoUri)
            }
        }catch(e:IOException){
            e.printStackTrace()
        }
        return image
    }

생성된 Uri 경로에 이미지를 MediaStore를 사용해서 읽어옵니다.

 btnCamera.setOnClickListener{
                if(checkPermission()){
                    //dispatchTakePictureIntent()
                    dispatchTakePictureIntentEx()
                }
            else{
                    requestPermission()
                }
        }

기존에 연결되어 있던 버튼 이벤트에서 신규로 선언한 dispatchTakePictureIntentEx 함수를 실행합니다.

else if( requestCode == REQUEST_CREATE_EX)
{
    if( photoURI != null)
    {
           val bitmap = loadBitmapFromMediaStoreBy(photoURI!!)
           GImageView.setImageBitmap(bitmap)
           photoURI = null
    }
}

onActivityResult 함수에서 이벤트 ID REQUEST_CREATE_EX를 필터링 후

이미지를 로드하는 loadBitmapFromMediaStoreBy 함수를 호출해서 이미지 뷰에 연결합니다.

카메라 촬영 후 갤러리를 확인하면 카메라 이미지를 확인할 수 있습니다.

원본 이미지를 사용해서 이미지뷰에 연결하면 해상도가 동일한 것을 확인할 수 있습니다.

카메라 이미지 해상도를 원본과 동일하게하기 위해서 별도 저장 후 로드하는 방법을 사용하게 가장 좋은 방법입니다.

이미지 정보가 시간에 따라서 변경되기 때문에 이름을 고정하면 한 개의 사진만 업데이트됩니다.

코틀린을 사용하면 코드가 매우 간결하기 때문에 매우 편리합니다.

객체를 주고받을 때 NULL 존재하기 때문에 ?를 사용하는 부분만 확인하면 어렵지 않은 코드입니다.

감사합니다.

오늘은 코틀린(Kotlin)을 사용해서 안드로이드 카메라 이벤트 이미지를 이미지 뷰에 출력해보겠습니다.

안드로이드 카메라를 사용하기 위해서 먼저 AndroidMainfest.xml에 속성을 추가해주세요.

<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-feature android:name="android.hardware.camera" android:required="true" />

 "required" 속성이 true일 경우는 반드시 카메라 사용 옵션입니다.

경우에 따라서 설정을 변경하면 됩니다.

카메라를 실행하기 위해서 activity_main.xml에 button을 추가합니다.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 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">

    <LinearLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical"
    >
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:orientation="horizontal">

        <Button
            android:id="@+id/btnGallery"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Gallery"
            tools:layout_editor_absoluteX="62dp"
            tools:layout_editor_absoluteY="16dp" />

        <Button
            android:id="@+id/btnCamera"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Camera"
            tools:layout_editor_absoluteY="76dp" />
    </LinearLayout>


    <ImageView
        android:id="@+id/GImageView"
        android:layout_width="match_parent"
        android:layout_height="500dp"
        tools:layout_editor_absoluteX="16dp"
        tools:layout_editor_absoluteY="124dp" />

    </LinearLayout>
    

</androidx.constraintlayout.widget.ConstraintLayout>

xml 추가 후 빌드하면 버튼이 정렬되어 출력됩니다.

"CAMERA" 버튼을 클릭하면 카메라를 실행하고, 촬영된 이미지를 하단 이미지 뷰에 추가하겠습니다.

카메라를 사용하기 위해서는 먼저 권한을 승인받아야 합니다.

 private fun requestPermission(){
        ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.READ_EXTERNAL_STORAGE,CAMERA),1)

    }
    private fun checkPermission():Boolean{

        return (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
                == PackageManager.PERMISSION_GRANTED && ContextCompat.checkSelfPermission(this,
        Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED)

    }
    @Override
    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)

        if( requestCode == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED){
            Toast.makeText(this, "권한 설정 OK", Toast.LENGTH_SHORT).show()
        }
        else
        {
            Toast.makeText(this, "권한 허용 안됨", Toast.LENGTH_SHORT).show()
        }
    }

ActivityCompat Class를 사용해서 카메라 사용 권한을 요청합니다.

checkPermission() 함수는 권한 여부를 확인할 수 있습니다.

onRequestPermissionsResult() 함수를 override 후 권한 승인에 따른 이벤트를 확인할 수 있습니다.

즉 권한이 없을 경우 앱 동작을 중단하거나, 메시지를 출력할 수 있습니다.

카메라를 실행하기 위해서 Intent를 실행합니다.

    private val REQUEST_IMAGE_CAPTURE = 2
    private fun dispatchTakePictureIntent() {
        Intent(MediaStore.ACTION_IMAGE_CAPTURE).also { takePictureIntent ->
            takePictureIntent.resolveActivity(packageManager)?.also {
                startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE)
            }
        }
    }

권한이 승인되면 MediaStore.ACTION_IMAGE_CAPTURE argument를 사용해서 Intent를 실행합니다.

이젠 버튼 이벤트를 연결해서 dispatchTakePictureIntent() 함수를 실행합니다.

btnCamera.setOnClickListener{
                if(checkPermission()){
                    dispatchTakePictureIntent()
                }
            else{
                    requestPermission()
                }
        }

button event에서 checkPermission() 함수를 실행 후 권한이 없다면 권한을 재 요청합니다.

권한 승인 되었다면 카메라를 실행합니다.

정상적으로 카메라 실행 화면을 확인할 수 있습니다.

카메라 촬영 버튼을 클릭하면 이미지가 저장되면서 이벤트가 발생합니다.

이전 시간에 배운 onActivityResult 이벤트를 사용해서 이미지를 저장합니다.

@Override
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        if( resultCode == Activity.RESULT_OK) {
            if (requestCode == GALLERY) {
                var ImnageData: Uri? = data?.data
                Toast.makeText(this, ImnageData.toString(), Toast.LENGTH_SHORT).show()
                try {
                    val bitmap = MediaStore.Images.Media.getBitmap(contentResolver, ImnageData)
                    GImageView.setImageBitmap(bitmap)
                } catch (e: Exception) {
                    e.printStackTrace()
                }
            }
            else if( requestCode == REQUEST_IMAGE_CAPTURE)
            {
                val imageBitmap :Bitmap? = data?.extras?.get("data") as Bitmap
                GImageView.setImageBitmap(imageBitmap)
            }
        }
    }

requestCode가 REQUEST_IMAGE_CAPTURE일 경우 "data" 이미지를 이미지 뷰에 연결할 수 있습니다.

Intent를 사용한 뷰 이벤트는 대부분 onActivityResult를 사용해서 필터링이 가능합니다.

촬영 후 정상적으로 이미지 뷰에 촬영한 사진이 출력됩니다.

일반적인 카메라 이미지를 사용할 경우는 Intent를 사용하면 매우 편리합니다.

하지만, 카메라 기능을 제어할 수 없기 때문에 카메라 기능을 사용할 경우는 별도 뷰를 개발해야 합니다.

감사합니다.

https://developer.android.com/training/camera/photobasics?hl=ko

오늘은 코틀린(Kotlin)을 사용해서 캘러리 뷰 이미지 클릭 이벤트에 대해서 알아보겠습니다.

먼저 layout을 변경하기 위해서 mainActivity.xml을 클릭합니다.

 <Button
        android:text="Gallery"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/btnGallery"   />

    <ImageView
        android:layout_width="match_parent"
        android:layout_height="500dp"
        android:id="@+id/GImageView" />

갤러리를 호출하기 위한 Button과 선택한 이미지를 출력하기 위한 ImageView를 선언합니다.

ImageView 크기는 원하는 크기로 설정하면 됩니다.

빌드하면 GALLERY BUTTON만 확인할 수 있습니다.

이제 MainActivity에서 버튼 이벤트를 생성해서 갤러리 호출 이벤트 연결이 필요합니다.

    private val GALLERY = 1
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        btnGallery.setOnClickListener{
            val intent: Intent = Intent(Intent.ACTION_GET_CONTENT)
            intent.setType("image/*")
            startActivityForResult(intent,GALLERY)
        }

    }

전역 변수로 GALLERY = 1로 정의해주세요.

Intent 갤러리 타입은 1이기 때문에 편하게 사용하기 위해서 정의하는 겁니다.

layout에서 선언한 button에 setOnClickListener 이벤트를 연결합니다.

갤러리는 Intent를 사용해서 호출합니다.

전체 이미지를 확인하기 위해서 "Image/*"로 정의합니다.

코드 작성 후 빌드하면 button 클릭 시 갤러리 화면을 확인할 수 있습니다.

이제 갤러리 이미지에서 이벤트를 연결하겠습니다.

 @Override
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        if( resultCode == Activity.RESULT_OK){
            if( requestCode ==  GALLERY)
            {
                var ImnageData: Uri? = data?.data
                Toast.makeText(this,ImnageData.toString(), Toast.LENGTH_SHORT ).show()
                try {
                    val bitmap = MediaStore.Images.Media.getBitmap(contentResolver, ImnageData)
                    GImageView.setImageBitmap(bitmap)
                }
                catch (e:Exception)
                {
                    e.printStackTrace()
                }
            }
        }
    }

onActivityResult 함수를 override 해줍니다.

onActivityResult 함수는 호출된 Activity 이벤트를 확인할 수 있습니다.

resultCode는 Activity 완료 이벤트를 확인할 수 있습니다.

requestCode는 호출 Code를 확인할 수 있습니다.

data에서는 현재 클릭한 Object URL 경로 확인이 가능합니다.

MediaStore 객체를 사용해서 URL 경로에 이미지를 Bitmap로 변경합니다.

마지막으로 Layout에 정의된 GImageView 객체에 setImageBitmap를 사용해서 BitMap을 출력합니다.

출력 결과 선택한 이미지를 ImageView에서 확인할 수 있습니다.

Intent를 사용해서 간단하게 갤러리 이미지를 확인할 수 있지만,

갤러리 뷰를 마음대로 조절할 수 없기 때문에 디바이스 종속적으로 사용만 가능합니다.

상기 기능은 갤러리에서 이미지를 선택할 경우 사용하면 매우 편리합니다.

감사합니다.

코틀린(Kotlin)도 다른 언어와 동일하게 함수를 사용할 수 있습니다.

코틀린에 가장 큰 함수 특징은 일급 객체로 사용이 가능합니다.

일급 객체는 일반적인 함수 형식과  엔티티로 적용하여 변수로 바로 사용이 가능하다.

함수 기본 형식은 (함수명) -> 반환 형식으로 되어 있습니다.

fun MakeString(mes : String): String{
    return mes + "  Create Message"
}

MakeString 함수는 mes String 매개변수를 받아서 String으로 반환합니다.

println(MakeString("함수 사용"))

println 함수를 사용해서 출력합니다.

출력 결과 입력된 "함수 사용" 뒤에 메시지가 추가되었습니다.

일반적인 함수는 함수를 만들어서 호출할 수 있습니다.

코틀린(Kotlin) 함수는 이런 함수를 변수 처럼 정의할 수 있습니다.

var MString:(String) -> String = fun(mes:String) = mes + " Create Message 2"

변수 MString에 함수를 직접 선언할 수 있습니다.

    println(MakeString("함수 사용"))

    println(MString("변수 함수 사용"))

MakeString 함수와 MString 변수를 출력 했습니다.

출력 결과 동일하게 입력 String에 추가 내용이 포함되어 있습니다.

함수에 사용되는 매개변수를 다양하게 사용이 가능합니다.

    var MString:(String) -> String = fun(mes:String) = mes + " Create Message 2"

    var a:(Int) -> Int = fun(i:Int) = i * 10

    println(a(7).toString())

    println(MakeString("함수 사용"))

    println(MString("변수 함수 사용"))

Int를 사용해서 추가 함수 a를 선언했습니다.

기존과 동일하게 println 함수를 사용해서 출력했습니다.

a 함수는 입력 변수에 10을 곱하는 형태로 7을 입력 시 70을 반환했습니다.

코틀린 함수는 매개변수 형식과 반환 형식을 자유롭게 사용할 수 있어 문법이 매우 편리합니다.

또한 외부 함수 정의가 아닌 내부에 함수를 정의를 사용할 수 있어 객체에 대한 처리를 완벽하게 수용할 수 있습니다.

내부 함수 정의 후 모호하다면 invoke() 메서드를 사용해서 모호함을 해결할 수 있다.

감사합니다.

코틀린이나 자바로 클래스를 정의할 경우 클래스 내부에 클래스를 다시 정의해야 하는 경우가 있습니다.

코틀린은 자바와 동일하게 최상위 클래스 내부에 클래스를 다시 배치할 수 있는 중첩 클래스(neted class)를 지원합니다.

중첩 클래스(neted class)

class nested{
    private val value:Int = 0

    class In{
        fun foo() = 7
    }
}

클래스 내부에 함수를 다른 클래스에 정의해서 접근할 수 있습니다.

nested class 내부에 In class를 정의하고 foo 메서드를 사용해서 멤버에 접근이 가능합니다.

nested.In().foo() 메서드를 사용해서 멤버 정보를 출력할 수 있습니다.

출력 결과 멤버에 저장된 7을 출력하게 됩니다.

중첩 클래스(neted class)에서 최상위 클래스에 정의된 인스턴스 변수나 메서드에 직접 접근이 불가능합니다.

중첩된 내부 클래스를 사용해서 객체 참조가 가능합니다.

class nested{
    private val value:Int = 0

    class In{
        fun foo() = 7
    }

    inner class innerIn{
        fun foo2() = 20
    }
}

코틀린(Kotlin) 중첩 클래스(neted class)에서 내부 클래스를 직접 접근하기 위해서는 inner 한정자를 사용해서 클래스를 정의하면 됩니다.

innerIn class는 inner로 정의 되었기 때문에 직접 foo2 메서드에 접근이 가능합니다.

nested를 선언하고 innerIn class에 직접 접근할 수 있습니다.

출력 결과 foo2 메서드에서 설정한 20을 확인할 수 있습니다.

중첩 클래스(neted class)는 내부 클래스를 직접 참조하거나, 간접적으로 참조할 수 있는 구조로 정의가 가능합니다.

Outer 클래스의 인스턴스를 먼저 만들어서 Inner 클래스를 접근하게 되면 모든 Outer 클래스를 멤버를 참조할 수 있어 하나의 인스턴스처럼 사용이 가능합니다.

감사합니다.

코틀린에서는 선언된 모든 하위 클래스를 확인할 수 있는 봉인 클래스(Sealed Class)가 있습니다.

봉인 클래스를 사용하면 상속 계층을 보호하면서 클래스를 정의할 수 있습니다.

봉인 클래스(Sealed Class)는 코틀린 1.1 이전 버전에서는 봉인 클래스를 내부에 정의했지만 1.1 버전부터는

봉인 클래스가 있는 파일 안에서 하위 클래스를 정의할 수 있게 되었습니다.

봉인 클래스가 하위에 정의되기 때문에 모든 하위 클래스를 한눈에 확인할 수 있습니다.

봉인 클래스(Sealed Class)

sealed class Mammal(val name:String)
class Cat(val catName: String) : Mammal(catName)
class Dog(val dogName:String) : Mammal(dogName)
class Human(val humanName:String, val job: String) : Mammal(humanName)

봉인 클래스(Sealed Class)를 선언하기 위해서는 sealed 한정자를 사용해서 선언하면 됩니다.

하위 클래스는 Mammal을 상속받아 접근이 가능합니다.

즉, 하위 클래스만 확장이 가능하고 개방이 안될 경우 다른 파일에서 사용이 불가능합니다.

개방은 조금 아래에서 확인해보겠습니다.

    fun greetMammal( mammal: Mammal) : String{
        when(mammal){
            is Cat -> return "안녕 고양이 ${mammal.name}"
            is Dog -> return "안녕 강아지 ${mammal.name}"
            is Human -> return "안녕 ${mammal.name} == 직업은 ${mammal.job}"
        }
    }
    
    Log.d(TAG,"-------- Sealed Classes ---------")

    Log.d(TAG, greetMammal(Cat("야옹이")))
        
    Log.d(TAG,"-------- Sealed END ---------")

greetMammal 함수를 사용해서 선언한 클래스를 when 제어문을 사용해서 확인할 수 있습니다.

Logcat View에서 봉인 클래스(Sealed Class) 출력 정보를 확인할 수 있습니다.

sealed class Mammal(val name:String)
class Cat(val catName: String) : Mammal(catName)
class Dog(val dogName:String) : Mammal(dogName)
class Human(val humanName:String, val job: String) : Mammal(humanName)

class Dog2: Cat("ddd")

봉인 클래스(Sealed Class)를 상속받은 클래스를 일반 클래스에서 상속받게 되면 봉인되어 있어 상속이 불가능합니다.

class Dog2에서 Cat class를 상속받으면 에러가 발생하는 것을 확인할 수 있습니다.

sealed class Mammal(val name:String)
open class Cat(val catName: String) : Mammal(catName)
class Dog(val dogName:String) : Mammal(dogName)
class Human(val humanName:String, val job: String) : Mammal(humanName)

class Dog2: Cat("ddd")

코틀린(Kotlin) 봉인 클래스(Sealed Class)를 다른 파일에서 사용하기 위해서는 open 한정자를 사용해서 개방을 해야 합니다.

Cat class를 개방하면 오류 없이 정상적으로 컴파일됩니다.

봉인 클래스(Sealed Class) 적용 사례

코틀린(Kotlin) 봉인 클래스(Sealed Class)는 상속 계층을 보호하는 기능이 가장 큰 특징이지만

링크 리스트나 이진트리 같은 데이터 형식 정의에 적용하면 데이터 상속에 따른 오류를 최소화할 수 있습니다.

또한 특정 클래스를 확장하지 못하게 하면서 특정 모듈에 API를 보호하면서 개발할 수 있습니다.

감사합니다.

play.kotlinlang.org/byExample/03_special_classes/03_Sealed%20Classes

코틀린에서 개발 시 상수를 열거해야 하는 경우가 있습니다.

코틀린이나 JAVA에서는 상수를 열거하기 위해서

열거형 클래스(Enum Class)를 사용할 수 있습니다.

열거형 클래스(Enum Class)를 사용하면 상수를 집합으로 관리할 수 있어 코드에 가독성이 높아집니다.

코틀린 열거형 클래스(Enum Class)를 사용하기 위해서는 "enum class"로 선언됩니다.

순차적으로 적용되기 때문에 원하는 상수를 입력하면 됩니다.

enum class State{
    IDLE,
    RUNNING,
    FINISHED
}

fun enumprint(){
      val selecteditem = State.valueOf("IDLE")
      Log.d(TAG, (selecteditem == State.RUNNING).toString())
}

코틀린 열거형 클래스(Enum Class)는 자바와 동일하게 vlaueOf 메소드를 사용해서 열거형을 확인할 수 있습니다.

코드 실행 결과 "selecteditem"에 저장된 "IDLE" 열거형과 "State.RUNNING" 열거형이 다른 것을 확인할 수 있습니다.

상수 집합을 간단하게 사용할 수 있어 열거형 클래스(Enum Class)는 다양한 데이터 집합에 꼭 필요한 요소입니다.

    fun enumprint2()
    {
        for( state in State.values()){
            Log.d(TAG, "${state.name} == ${state.ordinal}")
        }
    }

열거형 클래스(Enum Class)는 일반적으로 "values" 메소드를 사용해서 전체 열거형을 확인할 수 있습니다.

"name", "ordinal"을 사용해서 이름과 선언 값을 확인할 수 있습니다.

출력 결과 순차적으로 출력된 내용을 확인할 수 있습니다.

  fun enumprint3()
    {
        for( state in enumValues<State>())
        {
            Log.d(TAG, "enumValues : ${state.name} == ${state.ordinal}")
        }
    }

코틀린 열거형 클래스(Enum Class)는 도우미 메소드 enumValueOf를 이용해서도 열거형 클래스를 확인할 수 있습니다.

"enumValues"를 사용 후 열거형 클래스를 선언하면 전체 열거형 클래스를 for문으로 확인 가능합니다.

출력 결과 values 메소드를 사용한 결과와 동일한 내용을 확인할 수 있습니다.

코틀린(kotlin) 열거형 클래스(Enum Class)는 상수를 맞춤형 데이터로 연결할 수 있습니다.

일반적으로 선언할 경우 0번에서 부터 순차적으로 선언되지만, 별도 상수를 선언이 가능합니다.

코틀린 열거형 클래스(Enum Class) 선언 후 fun 별도 함수를 하나 추가했습니다.

enum class Color(val rgb: Int){
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF),
    YELLOW( 0xFFFF00);

    fun containsRed() = (this.rgb and 0xFF000 != 0)
}

fun enumprint4()
{
    val red = Color.RED
    Log.d(TAG, red.toString())
    Log.d(TAG, red.containsRed().toString())
    Log.d(TAG, Color.BLUE.containsRed().toString())
}

fun 함수는 열거형에 선언된 HEX 값을 확인하여 참, 거짓으로 리턴합니다.

red.containRed() 메서드를 실행하면 RED 값과 조건식이 맞기 때문에 참으로 출력됩니다.

반면 Color.BLUE.contatinsRed() 메서드를 선언하면 RED가 아니기 때문에 거짓을 리턴합니다.

코틀린(kotlin) 열거형 클래스(Enum Class)는 집합된 상수를 사용할 수 있어 가독성이 떨어지는 Int형보다 편리하게 사용할 수 있는 클래스입니다.

다양한 열거형을 클래스 내부에서 사용하게 되면 가독성을 더욱더 높일 수 있습니다.

감사합니다.

play.kotlinlang.org/byExample/03_special_classes/02_Enum

코틀린은 다양한 Class를 사용해서 가독성 높게 개발할 수 있습니다.

오늘은 데이터(Data)를 쉽게 사용할 수 있는 데이터 클래스(Data Class)를 알아보겠습니다.

서버에서 사용하는 데이터를 가져와서 저장하기 위해서 많이 사용되는 클래스입니다.

데이터 클래스(Data Class)는 애플리케이션 데이터 모델의 주요 구성요소입니다.

코틀린(Kotlin)에서는 클래스에 사용되는 속성에 게터, 세터가 지정됩니다.

var을 선언할 경우 읽기 쓰기 속성이기 때문에, 게터, 세터 모두 정의됩니다.

val을 선언할 경우는 읽기 속성만 있는 게터만 적용됩니다.

코틀린 데이터 클래스(Data Class)

데이터 클래스(Data Class)는 데이터의 무결성을 유지하기 위해서 val을 많이 사용합니다.

구조는 "data class"로 되어 있습니다.

class name을 지정하고 기본 인자를 선언하면 됩니다.

data class Book(val title:String, val price:Int, val type:Int)

Book 데이터 클래스는 val로 모두 선언되어 있어 직접 변경이 불가능합니다.

Book 데이터 클래스를 사용하기 위해서 다양한 함수를 적용했습니다.

fun books(){

        val book = Book("Kotlin", 20000, 1)

        Log.d(TAG, book.toString())

        val secondBook = Book("C#", 15000, 3)
        val thirdBook = Book("JAVA", 25000, 4)

        Log.d(TAG, book.hashCode().toString())
        Log.d(TAG, secondBook.hashCode().toString())
        Log.d(TAG, thirdBook.hashCode().toString())

        Log.d(TAG, book.copy().toString())
        Log.d(TAG,book.copy("Kotlin copy second").toString())
        Log.d(TAG,book.copy(price = 40000).toString())

        Log.d(TAG, secondBook.component1())
        Log.d(TAG, secondBook.component2().toString())
        Log.d(TAG, secondBook.component3().toString())

    }

클래스 선언은 JAVA와 다르게 new 없이 바로 선언하면 됩니다.

BOOK 클래스 타입을 확인하기 위해서. toString() 함수를 사용하면 모든 인수를 확인할 수 있습니다.

데이터 클래스는 두 인스턴스의 구조적 동등성을 비교하기 위해서 hashCode() 함수를 사용합니다.

hashCode() 함수를 사용할 경우 클래스 형식을 확인할 수 있습니다.

코틀린(Kotlin) 데이터 클래스(Data Class)는 직접 인수를 변경할 수 없기 때문에 copy() 함수를 사용해서 각 인수를 변경할 수 있습니다.

함수를 사용하기 위해서 MainActivity에 books() 함수를 호출했습니다.

데이터 클래스(Data Class) 인수를 확인하기 위해서는 component+번호() 함수를 사용할 수 있습니다.

데이터 클래스(Data Class) 인수에 따라서 함수가 순차적으로 변경됩니다.

함수 뒤에 자료형도 확인이 가능합니다.

모든 자료형은 .toString() 함수를 출력이 가능합니다.

Log View에서 출력된 데이터 클래스(Data Class) 정보를 확인할 수 있습니다.

.toString() 함수를 사용해서 인스턴스를 바로 확인할 수 있습니다.

HashCode() 함수를 사용하면 데이터 클래스의 Hash 값을 확인할 수 있습니다.

copy() 함수를 사용하면 인수를 변경할 수 있습니다.

코틀린(Kotlin) 데이터 클래스(Data Class)는 데이터 자료형을 프로그램에서 편리하게 사용할 수 있게 도와주는 매우 좋은 클래스입니다.

코틀린 파일을 따로 생성해서 데이터 클래스를 정의하면 더욱더 편리하게 사용할 수 있습니다.

감사합니다.

play.kotlinlang.org/byExample/03_special_classes/01_Data%20classes

오늘은 Android에서 디버깅 로그 사용법을 알아보겠습니다.

디버깅 로그는 Print() 함수와 동일하게 cmd에 출력하는 구조입니다.

Android를 개발할 경우 코드를 확인하기 위해서 Toast를 많이 사용합니다.

하지만 Toast 메시지 함수는 많은 이벤트에서 사용하기 매우 불편한합니다.

Android에서 코트린을 사용해서 디버깅을 출력하기 위해서는 먼저 Logcat View를 활성화해야 합니다.

android Studio 하단에서 Logcat 탭을 클릭하면 컴파일 시 모든 내용을 확인할 수 있습니다.

로그를 출력할 경우 Logcat View 내용이 출력됩니다.

Android Kotlin Log CODE

기본적으로 로그를 사용하기 위해서는 "import android.util.Log"를 포함해야 합니다.

Log 함수는 TAG 값을 기준으로 메시지를 추가할 수 있습니다.

class MainActivity : AppCompatActivity() {


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val TAG:String = "MainActivity : "

        Log.d(TAG, "Log ----- START")
        Log.d(TAG, "Log ----- INSERT")
        Log.d(TAG, "Log ----- END")

}

TAG를 String 변수로 초기화 해주세요.

이후 Log를 추가하고 싶은 라인에 Log.d(TAG, 메시지)를 추가하면 됩니다.

Log는 Debug, Info, Error, VERBOSE 등 다양한 타입으로 출력이 가능합니다.

컴파일을 진행하면 Log를 Logcat View에서 확인할 수 있습니다.

Log 정보를 타입에 따라서 잘 사용하면 오류가 발생할 경우 쉽게 원인을 파악할 수 있습니다.

감사합니다.

developer.android.com/reference/kotlin/android/util/Log

오늘은 코틀린 언어를 사용해서 Android에 설치된 모든 앱을 확인할 수 있는 프로그램을 만들어 보겠습니다.

코틀린(Kotlin)을 사용해서 설치된 안드로이드 앱을 확인하기 위해서는 많은 정보를 한눈에 확인할 수 있는 ListView를 사용하겠습니다.

안드로이드 ListView는 다양한 형태로 커스텀이 가능한 장점이 있습니다.

설치된 앱 이름과 아이콘을 ListView에 출력할 수 있는 구조로 만들어 보겠습니다.

먼저 ListView에 Item을 저장하기 위해서 새 파일 메뉴에서 kt class를 생성합니다.

item class에 String 변수 name과 Drawable 변수 image를 선언합니다.

package com.example.appcheck

import android.graphics.drawable.Drawable

class item ( val name : String,  val image : Drawable )

코틀린에서 class를 만드는 방법은 다양하지만, 쉽게 사용할 수 있는 생성자 초기화를 사용했습니다.

함수가 필요할 경우 "{, }"를 사용해서 선언하면 됩니다.

생성된 item class를 UI와 연동하기 위해서 layout 파일이 필요합니다.

신규 파일에서 layout을 선택하고 "main_lv_item.xml"을 생성해주세요.

main_lv_item.xml 파일에서 LinearLayout 하단에 item과 매핑할 수 있는 ImageView, TextView를 한 개씩 선언합니다.

가장 중요한 내용은 위치를 잡기 위해서 app:layout_constraintStart_toEndOf, app:layout_constraintTop_toTopOf에ImageView id인 AppImg로 설정해주세요.

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

    <ImageView
            android:id="@+id/AppImg"
            android:layout_width="52dp"
            android:layout_height="52dp"
            android:layout_marginBottom="4dp"
            android:layout_marginStart="8dp"
            android:layout_marginTop="4dp"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toTopOf="parent"
            app:srcCompat="@mipmap/ic_launcher_round" />

    <TextView
            android:id="@+id/processname"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginStart="16dp"
            android:textSize="20sp"
            android:textStyle="bold"
            app:layout_constraintStart_toEndOf="@+id/AppImg"
            app:layout_constraintTop_toTopOf="@+id/AppImg"
            />
</LinearLayout>

class, layout이 설정되면 activity_main.xml에 ListView를 선언해주십시오.

ListView 사용법은 아래 링크를 참고해주세요.

developer.android.com/reference/android/widget/ListView

Android는 개발 관련 자료가 잘 정리되어 있어 공부하기 정말 좋습니다.

ListView는 id만 정확하게 입력하면 됩니다.

이젠 LisrView에 item을 연결하기 위한 Adapter가 필요합니다.

새 파일에서 코틀린(Kotlin) .kt class 파일을 생성해주세요.

기본적으로 BaseAdapter을 상속받아서 item Array에 item을 저장하면 됩니다.

BaseAdapter에서 사용하는 기본 함수를 override 해줍니다.

getView 함수에서 View를 호출하기 직전에 main_lv_item.xml에 입력된 name, image를 저장하는 구조입니다.

class MainListAdapter(val context: Context, val itemlist : ArrayList<item>) : BaseAdapter() {
    override fun getView(p0: Int, p1: View?, p2: ViewGroup?): View {

        val view:View = LayoutInflater.from(context).inflate(R.layout.main_lv_item, null)
        val processname = view.findViewById<TextView>(R.id.processname)
        val itemIcon = view.findViewById<ImageView>(R.id.AppImg)

        val positem = itemlist[p0]
        processname.text = positem.name
        itemIcon.setImageDrawable(positem.image)
        return view
    }

    override fun getItem(p0: Int): Any {
        return itemlist[p0]
    }

    override fun getItemId(p0: Int): Long {
        return 0
    }

    override fun getCount(): Int {
        return itemlist.size
    }
}

마지막으로 등록된 Adapter을 ListView에 연결해야 합니다.

MainActivity로 이동해주세요.

arrayListOf를 사용해서 item 리스트를 생성합니다.

설치된 앱을 확인하기 위해서는 packageManager을 사용해야 합니다.

developer.android.com/reference/android/content/pm/PackageManager#getInstalledPackages(int)

packageManager.getinstalledPackages() 함수는 패키지 정보를 반환합니다.

0으로 설정할 경우는 DIRECT_BOOT_AWARE로 설치된 앱 리스트만 리턴합니다.

만약 설치된 모든 리스트롤 확인하고 싶다면 MATCH_DIRECT_BOOT_UNAWARE로 입력하면 됩니다.

반환된 앱 정보를 사용해서 MainListAdapter에 item 리스트를 저장합니다.

컴파일 결과 설치된 앱 리스트를 아이콘과 함께 확인할 수 있습니다.

설치된 앱을 모두 확인하는 과정에서 조금 시간이 걸립니다.

이번 시간에는 아주 간단하게 ListView를 사용해서 설치된 앱 리스트를 확인했습니다.

감사합니다.