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

기존에 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)
        }
    }

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