XMobile

서버에 https로 인증서를 적용하게되면 안드로이드에서 에러가 발생하게 됩니다.

   javax.net.ssl.SSLHandshakeException: java.security.cert.CertPathValidatorException: Trust anchor for certification path not found.
            at org.apache.harmony.xnet.provider.jsse.OpenSSLSocketImpl.startHandshake(OpenSSLSocketImpl.java:374)
            at libcore.net.http.HttpConnection.setupSecureSocket(HttpConnection.java:209)
            at libcore.net.http.HttpsURLConnectionImpl$HttpsEngine.makeSslConnection(HttpsURLConnectionImpl.java:478)
            at libcore.net.http.HttpsURLConnectionImpl$HttpsEngine.connect(HttpsURLConnectionImpl.java:433)
            at libcore.net.http.HttpEngine.sendSocketRequest(HttpEngine.java:290)
            at libcore.net.http.HttpEngine.sendRequest(HttpEngine.java:240)
            at libcore.net.http.HttpURLConnectionImpl.getResponse(HttpURLConnectionImpl.java:282)
            at libcore.net.http.HttpURLConnectionImpl.getInputStream(HttpURLConnectionImpl.java:177)
            at libcore.net.http.HttpsURLConnectionImpl.getInputStream(HttpsURLConnectionImpl.java:271)
    

정상적으로 접속하기 위해서 발급받은 인증서를 적용하도록 합니다.

자세한 내용은 https://developer.android.com/training/articles/security-ssl?hl=ko#kotlin 입니다.

코드 흐름은

1. 인증서를 로드 (LetEncryption에서 fullchain.pem을 사용)

2. 신뢰할 수있는 CA를 포함하는 키 스토어 생성

3. CA 입력을 신뢰하는 TrustManager 생성

4. TrustManager를 사용하는 SSLContext 생성

5. OkHttpcliennt 적용

으로 전체 소스는 하기와 같습니다.

companion object {
        private const val BASE_URL = SERVER_API
        var VERIFY_DOMAIN: String = "*.lottois.info"

        fun create(context: Context): ApiService {
            val logger =
                HttpLoggingInterceptor().apply { level = HttpLoggingInterceptor.Level.BODY }

            val tmf: TrustManagerFactory? = getTrustManagerFactory(context)
            var sslsocket = tmf?.let { getSSLSocketFactory(it) }
            val hostnameVerifier = HostnameVerifier { _, session ->
                HttpsURLConnection.getDefaultHostnameVerifier().run {
                    verify(VERIFY_DOMAIN, session)
                }
            }

            val client = OkHttpClient.Builder()
                .addInterceptor(logger)
                .sslSocketFactory(sslsocket, tmf?.trustManagers?.get(0) as X509TrustManager)
                .hostnameVerifier(hostnameVerifier)
                .build()

            return Retrofit.Builder()
                .baseUrl(BASE_URL)
                .client(client)
                .addConverterFactory(GsonConverterFactory.create())
                .build()
                .create(ApiService::class.java)
        }

        private fun getTrustManagerFactory(context: Context): TrustManagerFactory? {
            // 1. CA 로드 
            val cf: CertificateFactory = CertificateFactory.getInstance("X.509")
            val caInput: InputStream = context.resources.openRawResource(R.raw.fullchain)
            val ca: X509Certificate = caInput.use {
                cf.generateCertificate(it) as X509Certificate
            }

            // 2. 신뢰할 수있는 CA를 포함하는 키 스토어 생성
            val keyStoreType = KeyStore.getDefaultType()
            val keyStore = KeyStore.getInstance(keyStoreType).apply {
                load(null, null)
                setCertificateEntry("ca", ca)
            }

            // 3. CA 입력을 신뢰하는 TrustManager 생성
            val tmfAlgorithm: String = TrustManagerFactory.getDefaultAlgorithm()
            val tmf: TrustManagerFactory = TrustManagerFactory.getInstance(tmfAlgorithm).apply {
                init(keyStore)
            }
            return tmf
        }

        private fun getSSLSocketFactory(
            tmf: TrustManagerFactory
        ): SSLSocketFactory? {
            //4. TrustManager를 사용하는 SSLContext 생성
            val sslContext: SSLContext = SSLContext.getInstance("TLS")
            sslContext.init(null, tmf.trustManagers, null)
            return sslContext.socketFactory
        }
    }

AdMob 회원가입 및 프로젝트 생성 

1. admob 가입

https://apps.admob.com/

2. 앱 생성
- 앱 추가를 선택

- 안드로이드 선택 

3. 광고 단위 추가

 - 저는 배너 광고로 선택하였습니다.

프로젝트 적용

1. 프로젝트 수준 build.gradle

allprojects {
    repositories {
        google()
    }
}

2. 앱 수준 build.gradle

implementation 'com.google.android.gms:play-services-ads:19.5.0'

3. AndroidManifest.xml

앱 > 프로젝트생성 앱 > 앱 설정 앱 ID 하기 입력

하기 value에 가입한 admob에서 프로젝트를 생성한 앱 ID를 입력

<application>
        <!-- Sample AdMob app ID: ca-app-pub-3940256099942544~3347511713 -->
        <meta-data
            android:name="com.google.android.gms.ads.APPLICATION_ID"
            android:value="ca-app-pub-xxxxxxxxxxxxxxxx~yyyyyyyyyy"/>
    </application>

4. AdView 추가

노출되는것을 확인하기 위해 하기 adUnitId를 테스트 ID

ca-app-pub-3940256099942544/6300978111 로 진행하도록 합니다.

xml

<com.google.android.gms.ads.AdView
    xmlns:ads="http://schemas.android.com/apk/res-auto"
    android:id="@+id/adView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_centerHorizontal="true"
    android:layout_gravity="bottom"
    android:layout_marginBottom="5dp"
    ads:adSize="BANNER"
    ads:adUnitId="ca-app-pub-3940256099942544/6300978111">
</com.google.android.gms.ads.AdView>

소스코드

private lateinit var mAdView: AdView
...
fun setupAdMob() {
    MobileAds.initialize(
        this
    ) { }
    mAdView = findViewById(R.id.adView)
    val adRequest = AdRequest.Builder().build()
    mAdView.loadAd(adRequest)
}

5. 확인

 - 적용하여 정상적으로 노출하는 것을 확인할 수 있습니다.

자세한 내용은 하기 URL에서 확인할 수 있습니다.

https://developers.google.com/admob/android/quick-start?hl=ko

1. AES란

AES는 미국 정부가 채택한 이후 전 세계적으로 널리 사용되고 있다.

1977년 공표된 DES를 대체한 AES는, 암호화와 복호화 과정에서 동일한 키를 사용하는 대칭 키 알고리즘이다.

2.키 길이

AES 암호화 키의 길이는

128 bit - 16byte 

192 bit - 24byte 

256 bit - 32byte 

의 세 가지 중 하나가 될 수 있으며,

각각 AES-128, AES-192, AES-256으로 불린다. 

암호화 키의 길이에 따라 실행하는 라운드의 수가 다른데, 각각 10, 12, 14 라운드를 실행한다.

3. 운영방식

EBC, CBC차이

전자 코드북(electronic codebook, ECB)은 운용 방식 중 가장 간단한 구조를 가지며, 암호화하려는 메시지를 여러 블록으로 나누어 각각 암호화하는 방식으로 되어 있다.

전자 코드북은 모든 블록이 같은 암호화 키를 사용하기 때문에 보안에 취약하다.

암호 블록 체인 (cipher-block chaining, CBC) 방식은 1976년 IBM에 의해 개발되었다.[4] 각 블록은 암호화되기 전에 이전 블록의 암호화 결과와 XOR되며, 첫 블록의 경우에는 초기화 벡터가 사용된다. 초기화 벡터가 같은 경우 출력 결과가 항상 같기 때문에, 매 암호화마다 다른 초기화 벡터를 사용해야 한다.

CBC 방식은 현재 널리 사용되는 운용 방식 중 하나이다

4. AES256 CBC방식 소스 구현해보기

https://developer.android.com/reference/javax/crypto/Cipher

위 Cipher클래스에서 Algorithm Modes Paddings를 하기와 같이 설정하여 확인해 보도록 하겠습니다.

AES/CBC/PKCS5Padding으로 확인해보겠습니다.

PKCS5Padding은

AES는 블록사이즈가 16바이트 크기로 16바이트의 배수가 아니라면

마지막 블록의 빈 부분을 채워주는 패딩옵션으로 PKCS5Padding로 적용해보겠습니다.

* 참고할만한 java 소스 코드 확인시

AES 블록은 16byte이고 AES키 사이즈는 16, 24, 32이며 

라운드 횟수는 키사이즈에 의해서 라운드 횟수가 정해지고

IV사이즈는 블록사이즈와 동일하게 가져야 하는 것을 확인할 수 있습니다.

AESConstants.java

interface AESConstants {
    // AES block size in bytes.
    int AES_BLOCK_SIZE = 16;
    // Valid AES key sizes in bytes.
    // NOTE: The values need to be listed in an *increasing* order
    // since DHKeyAgreement depends on this fact.
    int[] AES_KEYSIZES = { 16, 24, 32 };
}

AESCrypt.java

키사이즈에 의해서 라운드 횟수가 정해지는것을 확인할 수 있습니다.

/**
  * Return The number of rounds for a given Rijndael keysize.
  *
  * @param keySize  The size of the user key material in bytes.
  *                 MUST be one of (16, 24, 32).
  * @return         The number of rounds.
  */
private static int getRounds(int keySize) {
    return (keySize >> 2) + 6;
}

CipherCore.java

블록사이즈와 initial vector사이즈가 동일한 것을 확인할 수 있습니다.

if (params instanceof IvParameterSpec) {
    ivBytes = ((IvParameterSpec)params).getIV();
    if ((ivBytes == null) || (ivBytes.length != blockSize)) {
        throw new InvalidAlgorithmParameterException
            ("Wrong IV length: must be " + blockSize +
              " bytes long");
    }
}

Cipher클래스를 이용해서 하기와 같이 구성을 해보았습니다.

//키길이 AES 256
private val KEY_SIZE = 32
private val SECRET_KEY = "0".repeat(KEY_SIZE)
//모드 CBC
private val AES_TRANSFORMATION = "AES/CBC/PKCS5PADDING"
//AES initial Vector == 블록사이즈 16고정
private val IV = "1234567890123456"
private val ivParameterSpec = IvParameterSpec(IV.toByteArray())
private fun secretKeySpec(): SecretKeySpec {
    return SecretKeySpec(SECRET_KEY.toByteArray(), "AES")
}

private fun encrypt(plainText: String): ByteArray  {
    val cipher = Cipher.getInstance(AES_TRANSFORMATION)
    cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec(), ivParameterSpec)
    return cipher.doFinal(plainText.toByteArray())
}

private fun decrypt(cipherText: ByteArray?): String {
    val cipher = Cipher.getInstance(AES_TRANSFORMATION)
    cipher.init(Cipher.DECRYPT_MODE, secretKeySpec(), ivParameterSpec)
    return String(cipher.doFinal(cipherText))
}

private fun encode(byteArray: ByteArray): ByteArray {
    val decodedBytes = Base64.encode(byteArray, Base64.DEFAULT)
    return decodedBytes
}

private fun decode(encodedString: String): ByteArray {
    val decodedBytes = Base64.decode(encodedString, Base64.DEFAULT)
    return decodedBytes
}

실행

val plainText = "|" + REQUEST_DATE
Timber.tag(TAG).i("plainText: " + plainText)
val encryptText = encode(encrypt(plainText))
Timber.tag(TAG).i("encrypt : " + encryptText)

var resultDecrypt = decrypt( decode(resultStr))
Timber.tag(TAG).i("result decrypt : " + resultDecrypt)

결과

plainText: |1604809558
encrypt : [B@162f532
decrypt : |1604809558

SO파일에 문자열을 숨기고 암호화키로 사용할 경우 감출 수 있는지 테스트 확인하기 위하여

기본 프로젝트를 이용하여 간단히 만들어 보도록 하겠습니다.

참고 URL

https://developer.android.com/studio/projects/add-native-code?hl=ko

프로젝트 생성

1. new project -> Native c++ 디폴트 프로젝트 생성

2. 빌드후 실행

3. 정상적으로 호출되는 것을 확인했고 소스코드를 확인해 보겠습니다.

생성한 프로젝트의 cpp>native-lib.cpp stringFromJNI메소드명을 사용할 Java_패키지_액티비티_stringFromJNI으로 이름 메소드 변경필요

extern "C" JNIEXPORT jstring JNICALL 
Java_패키지_액티비티_stringFromJNI(
        JNIEnv* env,
        jobject /* this */) {
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}

액티비티에서 사용 소스

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    // Example of a call to a native method
    findViewById<TextView>(R.id.sample_text).text = stringFromJNI()
}
external fun stringFromJNI(): String
companion object {
    init {
        System.loadLibrary("native-lib")
    }
}

so파일 export

1. Build > Build Bundles(s) / APK(s) > Build APK(s)를 선택합니다.

2. Build > Analyze APK를 선택합니다.

3. apk압축 해제후 lib하위 폴더에 so파일이 생성된 것을 확인할 수 있습니다.

1. 다른 방법으로

https://developer.android.com/ndk/guides/cmake?hl=ko

toolbar gradle 명령에서 externalNativeBuild를 실행하면

로그에 so 파일 생성되고 경로가 정보창으로

...

app/build/intermediates/cmake/release/obj/x86_64/libnative-lib.so

...

으로 생성된 것을 확인할 수 있습니다.

다른 프로젝트에서 사용하기

so 폴더 파일들을 사용할 프로젝트에 jniLibs폴더 생성 모두 복사

Timber.tag(TAG).i("jni : " + stringFromJNI())

external fun stringFromJNI(): String

companion object {
    // Used to load the 'native-lib' library on application startup.
    init {
        System.loadLibrary("native-lib")
    }
}

로그로 잘 찍히는 것을 확인하였습니다.

SO 파일 HEX 값 확인

이와 같이 테스트한 목적은 암호화키를 하드 코딩을 숨길 수 있을까하는 관점에서 테스트해보았으며

hex editor에 문자열이 노출되는 것을 확인되어 파악이 쉽진않겠지만 보안이 보장되지 않는것을 확인하였습니다.

이상입니다.

기존에 startActivityForResult() 및 onActivityResult() 를 통해서 결과를 받았던 것을 Activity Result API는 시스템에서 전달되면 결과를 등록, 실행 및 처리하기 위한 구성요소를 제공합니다.

참고 URL

https://developer.android.com/training/basics/intents/result?hl=ko

사용해보기 

1. gradle 설정 

implementation 'androidx.activity:activity-ktx:1.2.0-beta01'
implementation 'androidx.fragment:fragment-ktx:1.3.0-beta01'

2. ActivityResultLauncher 생성 

@RequiresApi(Build.VERSION_CODES.M)
private val singlePermissions = registerForActivityResult(
    ActivityResultContracts.RequestPermission()
) {  isSuccess ->
    Log.d(TAG, "isSuccess : " + isSuccess)
}

registerForActivityResult 파라미터로 ActivityResultContracts, 과 ActivityResultCallback를 넘기게 됩니다. 

3. 실행 

singlePermissions.launch(permissionName)

4. 2번의 결과 로그 확인 

정상적으로 동작하는것을 확인해 보았습니다. 

동작확인

@NonNull
@Override
public final <I, O> ActivityResultLauncher<I> registerForActivityResult(
        @NonNull ActivityResultContract<I, O> contract,
        @NonNull ActivityResultCallback<O> callback) {
    return registerForActivityResult(contract, mActivityResultRegistry, callback);

1. 위 registerForActivityResult를 통해서  ActivityResultLauncher를 생성한 인스턴스를 실행시키는 코드로 ActivityResultLauncher를 생성합니다.

2. 생성시 첫번재 파라미터로 전달된 RequestPermission는 권한요청을 위해  ActivityResultContract를 상속받아 구현되어 제공되고있는 클래스로 하기와 같이 구현되어 있습니다.

  간단히 보면 createIntent메소드에 permission을 전달받고 parseResult로 결과를 제공합니다.

3. 하기 FragmentActivity에서onRequestPermissionsResult 오버라이딩메소드에서 조건 검사를 통해서 등록이 되어있으면 doDispatch의 callback.onActivityResult(contract.parseResult(resultCode, data))를 통해서 전달이 되어 두번째 파라미터로 전달된 callback메소드로 결과를 받을 수 있습니다.

@CallSuper
    @Override
    @Deprecated
    public void onRequestPermissionsResult(
            int requestCode,
            @NonNull String[] permissions,
            @NonNull int[] grantResults) {
        if (!mActivityResultRegistry.dispatchResult(requestCode, Activity.RESULT_OK, new Intent()
                .putExtra(EXTRA_PERMISSIONS, permissions)
                .putExtra(EXTRA_PERMISSION_GRANT_RESULTS, grantResults))) {
            if (Build.VERSION.SDK_INT >= 23) {
                super.onRequestPermissionsResult(requestCode, permissions, grantResults);
            }
        }
    }


private <O> void doDispatch(String key, int resultCode, @Nullable Intent data,
        @Nullable CallbackAndContract<O> callbackAndContract) {
    if (callbackAndContract != null && callbackAndContract.mCallback != null) {
        ActivityResultCallback<O> callback = callbackAndContract.mCallback;
        ActivityResultContract<?, O> contract = callbackAndContract.mContract;
        callback.onActivityResult(contract.parseResult(resultCode, data));
    } else {
        mPendingResults.putParcelable(key, new ActivityResult(resultCode, data));
    }
}

간단히 사용해보았는데 기존에 onActivityResult를 오버라이딩해서 처리했던것을 제공된 api를 사용하여 하기 구글 예제와 같이 ActivityResultContract를 상속받아 구현을 하면 동작에 대한 요청과 결과의 소스관리과 명확해 질 것 같습니다.

class PickRingtone : ActivityResultContract<Int, Uri?>() {
        override fun createIntent(context: Context, ringtoneType: Int) =
            Intent(RingtoneManager.ACTION_RINGTONE_PICKER).apply {
                putExtra(RingtoneManager.EXTRA_RINGTONE_TYPE, ringtoneType)
            }

        override fun parseResult(resultCode: Int, result: Intent?) : Uri? {
            if (resultCode != Activity.RESULT_OK) {
                return null
            }
            return result?.getParcelableExtra(RingtoneManager.EXTRA_RINGTONE_PICKED_URI)
        }
    }

기존에 SharedPreferences에서 저장시 plain text인 것을  EncryptedSharedPreferences를 이용하면 암호화되어 저장하는 기능을 제공합니다. 

자세한 내용은 

https://developer.android.com/topic/security/data?hl=ko

Android 6.0(API 수준 23) 이상을 실행하는 기기에서 지원됩니다

App내에 ID, PASSWORD와 같은 중요정보를 AES 대칭키(암호화, 복호화 키 동일)를 이용하여  암호화를 했을때 문제점은 

키 관리였습니다.

프로젝트내에 하드코딩된 문자열은 보안상 취약하므로 노출의 위험이 있습니다.

EncryptedSharedPreferences를 이용하여 저장해 보도록 하겠습니다.

라이브러리 내부적으로 KeyStore를 이용하여 키 접근은 application레벨에서 접근이 안되어 안전하다고 볼 수 있습니다. 

https://developer.android.com/training/articles/keystore?hl=ko

gradle

implementation "androidx.security:security-crypto:1.0.0-rc03"

테스트 코드

val keyGenParameterSpec = MasterKeys.AES256_GCM_SPEC
val masterKeyAlias = MasterKeys.getOrCreate(keyGenParameterSpec)

val SharedPreferences = EncryptedSharedPreferences
        .create(
            "android",
            masterKeyAlias,
            requireContext(),
            EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
            EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
        )

val sharedPrefsEditor = SharedPreferences.edit()
sharedPrefsEditor?.apply {
    putString("id", "test")
    putString("password", "test")
}
sharedPrefsEditor.apply()

Log.d(TAG, SharedPreferences.getString("id", "not found").toString())

확인 XML 열어보기

/data/data/[packageName]/shared_prefs/android.xml 

<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<map>
    <string name="__androidx_security_crypto_encrypted_prefs_key_keyset__">12a90115c36d71e8bd3b39a8409886b09616e196b34e6df40b5a585f7223e34216ff542cb59dcd2759720826c95dad26a36aa7ce081d9e4eeddc9bc1aee8f1fb2cb473bf3d2acfb459e12cb760661372c8322e682cc7b5982ef9fccd6a9699643d75eca2b63adbaf166f5537cddded9c8b1c3daa0a8d7c68d88f292d9804b270878e281fb654ab77b40248725b91046cba9885af649384766684316b6be6813f351f7fb214391ba6c8d0a6fb1a44089cdaf29501123c0a30747970652e676f6f676c65617069732e636f6d2f676f6f676c652e63727970746f2e74696e6b2e4165735369764b65791001189cdaf295012001</string>
    <string name="ARK8rRzpTKbecLHO3yCiMMBaFHa2xCLZAJhtLVE=">ASyO+WIJmBqi+YFJPHKfX8DDLv8bZfqjVrL59TgD3CVmAfLH9elUqE+8hmVA</string>
    <string name="__androidx_security_crypto_encrypted_prefs_value_keyset__">128801c62e98509808338085528011581576775e3701e7483e4a9d27b89ba63e3406db1b8a6a71d9aee723173fe3feb24455eb6ddbc5ffcab51dc7b4e6b4dc831a4e3daf4f2e3612337734667cfd134949655e2d05623badf75f5cde42eb4148d6aed4edd5914779e0ee360c905c0ffa3192c11d8560bc78c5bc4d84ff651bfca54ba67c5786059ae4f1701a4408e2f2bbe402123c0a30747970652e676f6f676c65617069732e636f6d2f676f6f676c652e63727970746f2e74696e6b2e41657347636d4b6579100118e2f2bbe4022001</string>
    <string name="ARK8rRxdjEShL1rCHntSr1uL6GEkhB4=">ASyO+WKJ42K6D7TXNXO5Os3dxLGmJeGdlYVsIRYUVif85iONYyTlSkwWhzQl</string>
</map>

위와같이 암호화되어 저장되어 있는것을 확인하였습니다.

ViewModel 에서 api통신후 LiveData를 참조하여 정상적으로 갱신되었는지 확인하여 

정상 동작하는지 테스트를 진행해 보도록 하겠습니다. 

LiveData확인을 위한 확장함수를 활용하여 진행 하도록 합니다. 

https://github.com/android/architecture-components-samples/blob/master/LiveDataSample/app/src/test/java/com/android/example/livedatabuilder/util/LiveDataTestUtil.kt

build.gradle

// Testing dependencies
androidTestImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.3.5"
kaptAndroidTest "com.google.dagger:hilt-android-compiler:2.28.3-alpha"
androidTestImplementation "androidx.arch.core:core-testing:2.0.0"
// Espresso dependencies
androidTestImplementation "androidx.test.espresso:espresso-contrib:3.1.1"
androidTestImplementation "androidx.test.espresso:espresso-core:3.1.1"
androidTestImplementation "androidx.test.espresso:espresso-intents:3.1.1"
// Assertions
androidTestImplementation "androidx.test.ext:junit:1.1.0"
androidTestImplementation "com.google.truth:truth:0.42"
androidTestImplementation "androidx.test.uiautomator:uiautomator:2.2.0"
androidTestImplementation "androidx.work:work-testing:2.1.0"
androidTestImplementation "com.google.dagger:hilt-android-testing:2.28.3-alpha"
testImplementation "junit:junit:4.12"

MainRepository

class MainRepository(private val apiService: ApiService) {
    suspend fun getLotto(order: Int) = apiService.getLotto(order)
}

ApiService

interface ApiService {
    @GET("api/lotto")
    suspend fun getLotto(@Query("order") order: Int ): HomeDto

    companion object {
        private const val BASE_URL = "http://192.168.0.103:8181/"

        fun create(): ApiService {
            val logger = HttpLoggingInterceptor().apply { level = HttpLoggingInterceptor.Level.BODY }

            val client = OkHttpClient.Builder()
                .addInterceptor(logger)
                .build()

            return Retrofit.Builder()
                .baseUrl(BASE_URL)
                .client(client)
                .addConverterFactory(GsonConverterFactory.create())
                .build()
                .create(ApiService::class.java)
        }
    }
}

LiveDataTestUtil

@VisibleForTesting(otherwise = VisibleForTesting.NONE)
fun <T> LiveData<T>.getOrAwaitValue(
    time: Long = 2,
    timeUnit: TimeUnit = TimeUnit.SECONDS,
    afterObserve: () -> Unit = {}
): T {
    var data: T? = null
    val latch = CountDownLatch(1)
    val observer = object : Observer<T> {
        override fun onChanged(o: T?) {
            data = o
            latch.countDown()
            this@getOrAwaitValue.removeObserver(this)
        }
    }
    this.observeForever(observer)

    try {
        afterObserve.invoke()
        // Don't wait indefinitely if the LiveData is not set.
        if (!latch.await(time, timeUnit)) {
            throw TimeoutException("LiveData value was never set.")
        }
    } finally {
        this.removeObserver(observer)
    }

    @Suppress("UNCHECKED_CAST")
    return data as T
}

HomeViewModel

getLotto메소드는 retrofit을 사용하여 서버 api를 호출 후 homeDto 라이브 데이터를 갱신합니다.

class HomeViewModel @ViewModelInject constructor(val mainRepository: MainRepository
) : ViewModel() {
    var isLoading = MutableLiveData<Boolean>()
    var homeDto = MutableLiveData<HomeDto>()

    fun getLotto(order: Int) {
        try {
            isLoading.postValue(true)
            viewModelScope.launch {
                homeDto.postValue(mainRepository.getLotto(order))
            }
        } catch (e: Exception) {
            homeDto.postValue(null)
        } finally {
            isLoading.postValue(false)
        }
    }
}

HomeViewModelTest

Api 호출후 livedata를 확인하도록 합니다. 

@HiltAndroidTest
@ExperimentalCoroutinesApi
class HomeViewModelTest {
    private lateinit var viewModel: HomeViewModel
    private val hiltRule = HiltAndroidRule(this)
    private val instantTaskExecutorRule = InstantTaskExecutorRule()

    @get:Rule
    val rule = RuleChain
        .outerRule(hiltRule)
        .around(instantTaskExecutorRule)

    @Inject
    lateinit var mainRepository: MainRepository

    @Before
    fun setUp() {
        hiltRule.inject()
        val context = InstrumentationRegistry.getInstrumentation().targetContext
        viewModel = HomeViewModel(mainRepository)
    }

    @Test
    fun callRequest()  {
        //호출 후 livedata를 확인 
        viewModel.getLotto(0)
        assertTrue(viewModel.homeDto.getOrAwaitValue()._order > 0 )
    }
}

정상적으로 테스트 확인. 

이를 바탕으로 viewmodel livedata을 검증하는 방법에 대해서 확인해 보았습니다.  

Hilt는 프로젝트에서 수동 종속 항목 삽입을 실행하는 상용구를 줄이는 Android용 종속 항목 삽입 라이브러리입니다.

수동 종속 항목 삽입을 예는 

class LoginActivity: Activity() {
    private lateinit var mainViewModel: MainViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val apiService = ApiService(retrofit)
        val mainRepository = MainRepository(apiService)
        // Lastly, create an instance of MainViewModel with mainRepository
        mainViewModel = MainViewModel(mainRepository)
    }
}

이 접근 방식은 다음과 같은 문제가 있습니다.

1. 상용구 코드가 많습니다. 코드의 다른 부분에서 MainViewModel의 다른 인스턴스를 만들려면 코드가 중복될 수 있습니다.

2. 종속성은 순서대로 선언해야 합니다. RemoteRepository을 만들려면 MainViewModel 전에 인스턴스화해야 합니다.

3. 객체를 재사용하기가 어렵습니다. 여러 기능에 걸쳐 RemoteRepository를 재사용하려면 싱글톤 패턴을 따르게 해야 합니다. 모든 테스트가 동일한 싱글톤 인스턴스를 공유하므로 싱글톤 패턴을 사용하면 테스트가 더 어려워집니다.

Hilt를 사용하여 해결하기 

설정  

1 root build.gradle

buildscript {

    dependencies {
        classpath 'com.google.dagger:hilt-android-gradle-plugin:2.28-alpha'
    }
}

2.app/build.gradle

...
apply plugin: 'kotlin-kapt'
apply plugin: 'dagger.hilt.android.plugin'

android {
    ...
}

dependencies {
    implementation "com.google.dagger:hilt-android:2.29.1-alpha"
    kapt "com.google.dagger:hilt-android-compiler:2.29.1-alpha"
    implementation "androidx.hilt:hilt-common:1.0.0-alpha02"
    implementation "androidx.hilt:hilt-lifecycle-viewmodel:1.0.0-alpha02"
    kapt "androidx.hilt:hilt-compiler:1.0.0-alpha02"
}

3 .Hilt는 자바 8 기능을 사용합니다. 프로젝트에서 자바 8을 사용 설정하려면 app/build.gradle 파일에 다음을 추가합니다.

android {
  ...
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
}

구현 .

1. 애플리케이션 클래스에 Hilt를 설정합니다. 

@HiltAndroidApp
class ExampleApplication : Application() { ... }

2.Hilt 모듈은 @Module로 주석이 지정된 클래스입니다.

   인스턴스를 제공할 항목을 @Provides를 사용하여 Hilt에 알려줍니다. 

@Module
@InstallIn(ApplicationComponent::class)
object AppModule {
    @Provides
    @Singleton
    fun provideApiService(): ApiService {
        return ApiService.create()
    }

    @Provides
    fun provideMainRepository(apiService: ApiService): MainRepository {
        return MainRepository(apiService)
    }
}

Component 수명주기 

3. Jetpack라이브러리 ViewModel의 경우 ViewModel 객체의 생성자에서 @ViewModelInject 을 사용하여 ViewModel을 제공할 수 있습니다

class MainViewModel @ViewModelInject constructor(val mainRepository: MainRepository) : ViewModel() {
    fun getLotto(order: Int) = liveData(Dispatchers.IO) {
        emit(Resource.loading(data = null))
        try {
            emit(Resource.success(data = mainRepository.getLotto(order)))
        } catch (exception: Exception) {
            emit(Resource.error(data = null, message = exception.message ?: "Error Occurred!"))
        }
    }
}

4. 종목 항목 삽입  

    @AndroidEntryPoint를 사용하여 Android 클래스에 종속 항목을 제공합니다.

@AndroidEntryPoint
class HomeFragment : Fragment() {
    //@Inject lateinit var mainRepository: MainRepository
    private val viewModel: MainViewModel by viewModels()
    ...
}

Hilt는 현재 다음 Android 클래스를 지원합니다.

• Application(@HiltAndroidApp을 사용하여)

• Activity

• Fragment

• View

• Service

• BroadcastReceiver

마무리

Hilt와 같이 종속 항목 삽입(DI)은 프로그래밍에 널리 사용되는 기법으로, Android 개발에 적합합니다. DI의 원칙을 따르면 훌륭한 앱 아키텍처를 위한 토대를 마련할 수 있습니다.

종속 항목 삽입을 구현하면 다음과 같은 이점을 누릴 수 있습니다.

• 코드 재사용 가능

• 리팩터링 편의성

• 테스트 편의성

developer.android.com/training/dependency-injection/hilt-android?hl=ko

모든 Android 앱은 액세스가 제한된 샌드박스에서 실행됩니다. 자체 샌드박스 밖에 있는 리소스나 정보를 앱이 사용해야 하는 경우에는 앱이 적절한 권한을 요청해야 합니다. 앱에 권한이 필요하다고 선언하려면 권한을 앱 매니페스트에 표시한 후 사용자가 런타임에 각 권한을 승인하도록 요청합니다(Android 6.0 이상). 

1.매니페스트에 권한 추가

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

2 6.0이상 버전에 대해서 요청을 합니다. 

private fun setupUI() {
    binding.request.setOnClickListener {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            showCamera()
        } else {
            showCameraWithPermission(Manifest.permission.CAMERA
                , "게임에 필요한 권한 필요” //거절한 경우 필요 설명 
                , "카메라 권한 요청”) //거절한 경우 버튼 설명 
        }
    }
}

3. 권한 요청 

@RequiresApi(Build.VERSION_CODES.M)
private fun showCameraWithPermission(permissionName: String, reasonDesc: String, reasonButtonText: String) {
    if (checkSelfPermission(permissionName) == PackageManager.PERMISSION_GRANTED) {
        //허용
        showCamera()
    } else {
        if (shouldShowRequestPermissionRationale(permissionName)) {
            //거절한 경우 설명 후 재 요청.
            Snackbar.make(binding.mainLayout, reasonDesc, Snackbar.LENGTH_INDEFINITE)
                .setAction(reasonButtonText
                ) {
                    requestPermissions(
                        arrayOf(permissionName),
                        PERMISSION_REQUEST_CAMERA
                    )
                }.show()
        } else {
            //거절기록 없을때 최초 false 권한 요청
            requestPermissions(
                arrayOf(permissionName),
                PERMISSION_REQUEST_CAMERA
            )
        }
    }
}

4. 콜백 응답 

@RequiresApi(Build.VERSION_CODES.M)
override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<String>,
    grantResults: IntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    if (requestCode == PERMISSION_REQUEST_CAMERA) {
        if (grantResults.size == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            Toast.makeText(this, "권한 성공", Toast.LENGTH_SHORT).show()
            showCamera()
        } else {
            if (shouldShowRequestPermissionRationale(Manifest.permission.CAMERA)) {
                Toast.makeText(this, "권한 거절", Toast.LENGTH_SHORT).show()
            } else {
                //거부 및 다시 묻지 않기
                Toast.makeText(this,  "앱 기능 실행을 위해서는 설정화면에서 권한을 허용해주세요 ", Toast.LENGTH_LONG).show();
            }
        }
    }
}

참고

developer.android.com/guide/topics/connectivity/bluetooth?hl=ko

1. 권한 설정 

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<!-- If your app targets Android 9 or lower, you can declare ACCESS_COARSE_LOCATION instead. -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

2. 블루투스 지원되는지 확인  및 블루투스 활성화 

mBlueAdapter = BluetoothAdapter.getDefaultAdapter()

//check if bluetooth is available or not
if (mBlueAdapter == null) {
	showToast("bluetooth is not available")
    finish()
 } else {
 	mBlueAdapter?.let {
    	if (!it.isEnabled()) {
        	showToast("Turning On Bluetooth...")
        	//intent to on bluetooth
        	val intent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
        	startActivityForResult(intent, REQUEST_ENABLE_BT)
        } else {
       		 showToast("Bluetooth is already on")
        }
	}
}

3. 페어링된 기기 목록 

val pairedDevices: Set<BluetoothDevice>? = bluetoothAdapter?.bondedDevices
pairedDevices?.forEach { device ->
    val deviceName = device.name
    val deviceHardwareAddress = device.address // MAC address
}

4. 클라이언트로 연결  

private inner class ConnectThread(device: BluetoothDevice) : Thread() {
    private val mmSocket: BluetoothSocket? by lazy(LazyThreadSafetyMode.NONE) {
        device.createRfcommSocketToServiceRecord(MY_UUID)
    }

    public override fun run() {
        // Cancel discovery because it otherwise slows down the connection.
        bluetoothAdapter?.cancelDiscovery()
        mmSocket?.use { socket ->
            // Connect to the remote device through the socket. This call blocks
            // until it succeeds or throws an exception.
            socket.connect()
            // The connection attempt succeeded. Perform work associated with
            // the connection in a separate thread.
            manageMyConnectedSocket(socket)
        }
    }

    // Closes the client socket and causes the thread to finish.
    fun cancel() {
        try {
            mmSocket?.close()
        } catch (e: IOException) {
            Log.e(TAG, "Could not close the client socket", e)
        }
    }
}