[Java][Kotlin][Android] 안드로이드 자바와 코틀린 함께 사용하기 - 안드로이드 Legacy 코드 유지보수 하기 (2)

안녕하세요 👋

오늘은 저번 포스팅에 이어서 Legacy 코드 유지보수 하는 방법에 대해서 알아보려 합니다 😎

오늘 포스팅할 내용은 자바 코드를 코틀린으로 변환하는 방법에 대해서 포스팅해보려 합니다.

코틀린과 자바를 함께 사용하는 방법에 대해서는 이전 포스팅을 참고 부탁드립니다!

[Java][Kotlin][Android] 안드로이드 자바와 코틀린 함께 사용하기 - 안드로이드 Legacy 코드 유지보수 하

---

Java 파일 Kotlin으로 변환하기

아래와 같이 원하는 파일을 'Convert Java File to Kotlin File'을 통해 변환해 줍니다.

 

코틀린으로 변환하는 방법

 

자동으로 변환이 완료된 후 아래와 같은 팝업이 나타나는데 그대로 진행시켜 줍니다. (한마디로 더 좋은 코드가 있는데 변한 시켜 줄까?)

 

 

이러면 간단하게 Java코드가 Kotlin코드로 변환되는 것을 보실 수 있습니다 🤩

 

이렇게만 끝나면 재미없으니 RxJava로 되어있던 부분을 Coroutine으로 변환하는 작업까지 함께 진행해보려 합니다.

 

기존

// RestApi.kt
interface RestApi {
    @GET(Utils.GET_BEACH_CONGESTION_URL)
    fun getBeachCongestion() : Single<BeachListDTO>
}

// BeachRepository.kt
interface BeachRepository {
    /**
     * 해수욕장 혼잡도 가져오기
     * **/
    fun getBeachCongestion() : Single<BeachListDTO>
}

// BeachRepositoryImpl.kt
class BeachRepositoryImpl @Inject constructor(
    private val restApi: RestApi
) : BeachRepository {
    /**
     * 해수욕장 혼잡도 가져오기
     * **/
    override fun getBeachCongestion(): Single<BeachListDTO> {
        return restApi.getBeachCongestion()
    }
}

 

기존 코드는 Rx를 활용하기 위해 Single객체를 반환하도록 구성되어 있었습니다.

해당 부분을 함께 바꿔보도록 하겠습니다.

 

변경 후

// RestApi.kt
interface RestApi {
    @GET(Utils.GET_BEACH_CONGESTION_URL)
    suspend fun getBeachCongestion() : Response<BeachListDTO>
}

// BeachRepository.kt
interface BeachRepository {
    /**
     * 해수욕장 혼잡도 가져오기
     * **/
    suspend fun getBeachCongestion() : Flow<NetworkResult<BeachListDTO>>
}

// BeachRepositoryImpl.kt
class BeachRepositoryImpl @Inject constructor(
    private val restApi: RestApi
) : BeachRepository {
    /**
     * 해수욕장 혼잡도 가져오기
     * **/
    override suspend fun getBeachCongestion(): Flow<NetworkResult<BeachListDTO>> {
        val response = restApi.getBeachCongestion()
        return if(response.isSuccessful) {
            flow{
                emit(NetworkResult.Success(response.body()!!))
            }
        } else {
            flow{
                emit(NetworkResult.Failure("네트워크 통신에 실패했습니다!"))
            }
        }
    }
}

 

위처럼 Single 객체를 걷어내고 Flow를 반환하도록 수정하였습니다.

이어서 ViewModel과 Activity코드를 바꿔보도록 하겠습니다.

 

기존

@HiltViewModel
public class MainViewModel extends ViewModel {
    private BeachRepository mBeachRepository;
    private CompositeDisposable mCompositeDisposable;

    private MutableLiveData<List<BeachDTO>> mBeachList = new MutableLiveData<>();
    public LiveData<List<BeachDTO>> getBeachList() {
        return mBeachList;
    }

    private MutableLiveData<String> mToastMessage = new MutableLiveData<>();
    public void setToastMessage(String message) {
        mToastMessage.setValue(message);
    }
    public MutableLiveData<String> getToastMessage() {
        return mToastMessage;
    }

    @Inject
    MainViewModel(BeachRepository repository){
        mBeachRepository = repository;
    }

    /**
     * RxJava를 통해 해수욕장 혼잡도를 가져오는 메소드
     * **/
    public void callAllBeachList() {
        if(mCompositeDisposable == null){
            mCompositeDisposable = new CompositeDisposable();
        }
        mCompositeDisposable.add(
                mBeachRepository.getBeachCongestion()
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribeWith(new DisposableSingleObserver<BeachListDTO>(){
                            @Override
                            public void onSuccess(@NonNull BeachListDTO beachListDTO) {
                                mBeachList.setValue(beachListDTO.getAllBeachList());
                            }

                            @Override
                            public void onError(@NonNull Throwable e) {
                                mToastMessage.setValue("통신에 실패했습니다!");
                            }
                        })
        );
    }

    @Override
    protected void onCleared() {
        super.onCleared();
        if(mCompositeDisposable != null){
            mCompositeDisposable.clear(); // ViewModel이 clear 될때 CompositeDisposable 삭제
            mCompositeDisposable = null;
        }
    }
}

 

변경 후

sealed class NetworkResult<T> {
    data class Loading<T>(val isLoading : Boolean) : NetworkResult<T>()
    data class Success<T>(val data : T) : NetworkResult<T>()
    data class Failure<T>(val errorMessage : String) : NetworkResult<T>()
}

class MainViewModel @Inject constructor(
    private val beachRepository : BeachRepository
    ) : ViewModel() {
    private val _beachList = MutableStateFlow<List<BeachDTO>>(emptyList())
    val beachList: StateFlow<List<BeachDTO>>
    get() = _beachList

    /**
     * Coroutine과 Flow를 네트워크 통신을 하는 함수
     */
    fun callAllBeachList() {
        viewModelScope.launch {
            beachRepository.getBeachCongestion().collect{ result ->
                when(result){
                    is NetworkResult.Success -> {
                        _beachList.value = result.data.getAllBeachList()
                    }

                    is NetworkResult.Failure -> {
                        Log.d(TAG, "callAllBeachList: ${result.errorMessage}")
                    }

                    is NetworkResult.Loading -> {
                        Log.d(TAG, "callAllBeachList: Loading...")
                    }
                }
            }
        }
    }
}

Rx를 걷어내고 해당 부분을 Corouine을 통해 값을 수신하도록 수정하였습니다.

아울러, LiveData를 사용하던 부분도 StateFlow를 사용하도록 수정하였습니다 :)

 

기존

@AndroidEntryPoint
public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    private ActivityMainBinding mBinding;
    private MainViewModel mViewModel;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mBinding = DataBindingUtil.setContentView(this , R.layout.activity_main);
        mViewModel = new ViewModelProvider(this).get(MainViewModel.class);
        mViewModel.callAllBeachList();
        observeData();
    }

    private void observeData() {
        mViewModel.getToastMessage().observe(this, new Observer<String>() { // Toast Message
            @Override
            public void onChanged(String message) {
                Toast.makeText(MainActivity.this, message , Toast.LENGTH_SHORT).show();
            }
        });

        mViewModel.getBeachList().observe(this, new Observer<List<BeachDTO>>() {
            @Override
            public void onChanged(List<BeachDTO> beachDTOs) {
                for(BeachDTO beach : beachDTOs){
                    Log.d(TAG, "onChanged: " + beach.toString());
                }
            }
        });
    }
}

 

변경 후

private const val TAG = "MainActivity"

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    private var binding: ActivityMainBinding? = null
    private val viewModel : MainViewModel by viewModels()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = DataBindingUtil.setContentView(this, R.layout.activity_main)
        viewModel.callAllBeachList()
        observeData()
    }

    private fun observeData() {
       with(viewModel){
           lifecycleScope.launch{
               repeatOnLifecycle(Lifecycle.State.STARTED){
                   launch {
                       beachList.collect{ list ->
                           if(list.isNotEmpty()){
                               Log.d(TAG, "observeData: $list")
                           }
                       }
                   }
               }
           }
       }
    }
}

마지막으로 Activity 코드입니다.

---

간단한 예제를 적용해 본 것이지만 코드가 매우 간결해지는 것이 느껴졌습니다.

여러분들의 생각은 어떠신가요? 🤔

 

이상으로 포스팅을 마치며

Legacy코드를 유지 보수하는 여러분들에게 많은 도움이 되었으면 좋겠습니다.

 

오늘도 즐코하세요 :)