반응형

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

코틀린은 자바와 동일하게 최상위 클래스 내부에 클래스를 다시 배치할 수 있는 중첩 클래스(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

 

Kotlin Playground: Edit, Run, Share Kotlin Code Online

 

play.kotlinlang.org

 

반응형
반응형

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

코틀린이나 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

 

Kotlin Playground: Edit, Run, Share Kotlin Code Online

 

play.kotlinlang.org

 

반응형
반응형

코틀린은 다양한 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

 

Kotlin Playground: Edit, Run, Share Kotlin Code Online

 

play.kotlinlang.org

 

반응형
반응형

오늘은 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

 

Log  |  Android 개발자  |  Android Developers

 

developer.android.com

 

반응형
반응형

오늘은 코틀린 언어를 사용해서 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

 

ListView  |  Android 개발자  |  Android Developers

 

developer.android.com

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  |  Android 개발자  |  Android Developers

 

developer.android.com

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

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

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

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

 

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

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

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

감사합니다.

반응형
반응형

코틀린으로 안드로이드 개발 시 layout에 Activity_main.xml을 인식 못하는 오류가 발생했습니다.

소스에는 activity_main.xml이 존재하지만 찾을 수 없다는 오류가 출력됩니다.

Unresolved reference: activity_main 

이건 뭐여.

옵션 설정을 변경해도 동일한 에러가 계속 발생해서 구글링 해보니까.

import android.R 이 문제였습니다.

android.R이 import되면서 다른 내용을 찾고 있는 것으로 생각됩니다.

import android.R을 삭제하면 정상적으로 Activity_main을 확인할 수 있습니다.

 

반응형
반응형

오늘은 코틀린을 사용해서 안드로이드 인트로 화면을 만들어 보겠습니다.

코틀린 안드로이드 인트로

기본적인 인트로 화면으로 이미지를 추가해서 전환하는 방식으로 코드를 진행하겠습니다.

코틀린 안드로이드 인트로

먼저 안드로이드 스튜디오 및 IntelliJ을 사용해서 안드로이드 컴파일할 수 있는 환경을 구성해주세요.

전 유료 버전인 IntelliJ를 사용해보겠습니다.

안드로이드 스튜디오 개발 회사에서 만든 툴이기 때문에 비슷한 부분이 많이 있습니다.

먼저 "Empty Activity" 프로젝트를 생성해줍니다.

코틀린 안드로이드 인트로

안드로이드 인트로화면은 Activity를 호출해주는 방식이기 때문에 먼저 IntroActivity를 생성해줍니다.

이번에는 안드로이드 인트로에 사용할 이미지를 등록해주세요.

drawable 폴더에서 우클릭을 사용해서 Explorer을 오픈해서 이미지를 복사하면 자동으로 drawable 하위에 이미지가 등록됩니다.

코틀린 안드로이드 인트로

등록된 이미지를 클릭하면 확인할 수 있습니다.

코틀린 안드로이드 인트로

처음에 신규로 생성한 introlActivity.kt 파일을 클릭해서 코드를 입력해주세요.

class introlActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_introl)

        var handler = Handler()
        handler.postDelayed( {
            var intent = Intent( this, MainActivity::class.java)
            startActivity(intent)
        }, 3000)
    }

    override fun onPause() {
        super.onPause()
        finish()
    }
}

Intent를 사용해서 MainActivity를 3초 후에 이동하는 코드입니다.

onPause가 호출되면서 대기상태일 때 introActivity는 종료시키는 코드도 추가해주세요.

 

 

 

코틀린 안드로이드 인트로

인트로 레이아웃은 ImageView를 사용해서 고정시켜줍니다.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".introlActivity">

    <ImageView
            android:id="@+id/introlImg"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:scaleType="fitXY"
            android:src="@drawable/moon"
    />

</androidx.constraintlayout.widget.ConstraintLayout>

마지막으로 등록된 메인 Activity 정보를 변경해줍니다.

코틀린 안드로이드 인트로

AndroidManifest.xml에서 MainActivity와 .introlActivity를 바꿔주면 IntrolActivity가 먼저 호출되면서

3초 후 MainActivity가 호출됩니다.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.example.p365language">

    <application
            android:allowBackup="true"
            android:icon="@mipmap/ic_launcher"
            android:label="@string/app_name"
            android:roundIcon="@mipmap/ic_launcher_round"
            android:supportsRtl="true"
            android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
        </activity>
        <activity android:name=".introlActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
    </application>

</manifest>

정상적으로 코딩되었다면 빌드해주세요.

코틀린 안드로이드 인트로

인트로로 설정된 Activity가 먼저 호출되는 것을 확인할 수 있습니다.

코틀린 안드로이드 인트로

3초 후 메인화면으로 이동합니다.

인트로 화면은 앱 실행과 동시에 사용자에게 가장 큰 기대를 줄 수 있는 중요한 내용입니다.

안드로이드 인트로 화면을 사용해서 앱을 더욱더 멋지게 개발해보세요.

감사합니다.

반응형
반응형

Toast는 안드로이드에서 메시지를 출력하기 위한 함수입니다.

오늘은 코틀린에서 Toast 사용법을 알아보겠습니다.

Toast를 사용하기 전에 먼저 버튼을 추가해주세요.

안드로이드에서 빈 프로젝트를 생성하고 layout에서 activity_main.xml에 아래 코드를 추가해주세요.

<?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"
    tools:context=".MainActivity">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center"
        android:padding="20dp"
        android:orientation="horizontal">
        <Button
            android:id="@+id/btn_Toast"
            android:text="POP Toast"
            android:textAllCaps="false"
            android:padding="20dp"
            android:textSize="20dp"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content" />
    </LinearLayout>

</androidx.constraintlayout.widget.ConstraintLayout>

코드 내용은 간단하게 중앙에 버튼을 배치하기 위한 내용입니다.

출력 결과 중앙에 버튼을 확인할 수 있습니다.

이제 메시지를 출력하기 위해서 Toast를 사용해보겠습니다.

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        var btnToast : Button = findViewById(R.id.btn_Toast)

        btnToast.setOnClickListener{
            Toast.makeText(this, "Toast Start", Toast.LENGTH_SHORT).show()
        }
    }
}

MainActivity.kt에서 버튼에 클릭 이벤트를 연결합니다.

Toast 출력은 Toast.LENGTH_SHORT를 사용해서 짧게 출력합니다.

"POP Toast" 버튼을 클릭하면 아래쪽에 "Toast Start" 메시지를 확인할 수 있습니다.

 var btnToast : Button = findViewById(R.id.btn_Toast)

        btnToast.setOnClickListener{
            Toast.makeText(this, "Toast Start", Toast.LENGTH_LONG).show()
        }

Toast 타입을 Toadt.LENGTH_LONG로 설정합니다.

메시지 출력이 조금 더 길게 출력됩니다.

Toast는 LENGTH_SHORT일 경우는 2~3초 출력하고, LENGTH_LONG일 경우는 5초 정도 출력합니다.

안드로이드 코딩 시 Log를 사용하는 방법도 있지만, 다양한 출력을 사용자에게 인지 시켜주기 위해서는 Toast를 많이 사용합니다.

감사합니다.

반응형
반응형

오늘은 코틀린에서 가변 인자를 사용하고 싶을 경우 어떻게 사용해야 하는지 알아보겠습니다.

함수를 사용할 경우 고정된 파라미터를 사용하기도 하지만 가변적인 배열을 사용하고 싶은 경우도 있습니다.

코틀린에서는 이런 경우 vararg를 사용해서 배열을 정의합니다.

    fun IntMax(vararg numbers:Int):String
    {
        val sum = numbers.max()
        return sum.toString()
    }
    
    val rString = IntMax(2,4,7,9,10,15)
    Toast.makeText(this, rString, Toast.LENGTH_SHORT).show()

vararg 를 선언하게 되면 파라미터가 배열러 인식됩니다.

아규먼트(argument) 2, 4, 7, 9, 10, 15를 입력하면 MAX 항목인 15를 리턴합니다.

출력시 15를 확인할 수 있습니다.

INT 형태 배열을 사용해서 INT 가변 인자를 확인 할 수 있습니다.

그럼 이번에는 String을 사용해보겠습니다.

    fun StringAll( vararg StringList:String):String{
        val rText = StringList.joinToString()
        return rText
    }
    
    val rString = StringAll("A","S","D", "H", "I")
    Toast.makeText(this.application, rString, Toast.LENGTH_SHORT).show()

StringAll 함수는 파라미터(parameter) StringList를 vararg로 선언했습니다.

함수 내부에서 String 배열을 확인해서 입력된 아규먼트를 확인할 수 있습니다.

StringAll 함수는 입력된 String를 연결해서 리턴하게 되어 있습니다.

출력 결과 "A,S.D.H.I"를 확인 할 수 있습니다.

vararg는 다른 파라미터와 함께 사용이 가능합니다.

 

 

 

fun AllValue( Value1:Int, Value2:String, vararg StringList:String):String{
        val rText = StringList.joinToString()
        val AllText = Value1.toString() + Value2 + rText
        return AllText
    }

val rString = AllValue(123,"더하기","D", "H", "I")
Toast.makeText(this.application, rString, Toast.LENGTH_SHORT).show()

AllValue 함수는 파라미터 INT, String, vararg String를 사용합니다.

아규먼트 123, "더하기", "D", "H", "I"를 입력합니다.

결과는 "123더하기D,H,J" 입니다.

vararg는 다양한 가변 인자를 사용해서 함수를 유연하게 생성할 수 있습니다.

함수에 한개의 vararg만 사용이 가능합니다.

오늘은 코틀린(Kotlin) vararg에 대해서 알아보았습니다.

감사합니다.

반응형

+ Recent posts