CommonUtils

공통적으로 사용하는 util을 모아놓음, 클래스가 아닌 최상위 객체로 구현

enableNetwork

Return : boolean
네트워크 연결상태를 체크한다.

fun Context.enableNetwork(): Boolean {
    var isNetwork = false
    val manager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

    val activeNetwork = manager.activeNetworkInfo
    if (activeNetwork != null && activeNetwork.isConnected) {
        val networkType = activeNetwork.type
        if (networkType == ConnectivityManager.TYPE_WIFI || networkType == ConnectivityManager.TYPE_MOBILE) {
            isNetwork = true
        }
    }

    return isNetwork

}

finishApp

앱 종료 팝업을 생성한다.

fun Context.finishApp(msg: String) {

    val builder = AlertDialog.Builder(this)
    builder.setTitle("확인")
    builder.setMessage(msg)
    builder.setPositiveButton(android.R.string.yes) { d, _ ->
        d.dismiss()
        if(this is Activity){
            this.finishAffinity()
        }
    }
    builder.setNegativeButton(android.R.string.no){d, _->
        d.dismiss()
    }
    builder.show()

}

rootCheck01

기기가 루팅되어 있는지 판단한다.

fun Context.rootCheck01(): Boolean {
    val arrayOfString = arrayOf(           
        getString(com.enabledaonsoft.thecampnew.R.string.root_check_01),
        getString(com.enabledaonsoft.thecampnew.R.string.root_check_02),
        getString(com.enabledaonsoft.thecampnew.R.string.root_check_03),
        getString(com.enabledaonsoft.thecampnew.R.string.root_check_04),
        getString(com.enabledaonsoft.thecampnew.R.string.root_check_05),
        getString(com.enabledaonsoft.thecampnew.R.string.root_check_06)
    )
    var i = 0
    while (true) {
        if (i >= arrayOfString.size) {
            return false
        }
        if (File(arrayOfString[i]).exists()) {
            return true
        }
        i++
    }
}

rootCheck02

기기가 루팅되어있는지 확인한다.

fun Context.rootCheck02(): Boolean {
    val arrayOfString =
        arrayOf(getString(com.enabledaonsoft.thecampnew.R.string.root_check_07),
            getString(com.enabledaonsoft.thecampnew.R.string.root_check_08))
    var i = 0
    while (true) {
        if (i >= arrayOfString.size) {
            return false
        }
        if (File(arrayOfString[i]).exists()) {
            return true
        }
        i++
    }
}

rootCheck03

기기가 루팅되어있는지 확인한다.

fun Context.rootCheck03(): Boolean {
    var flag: Boolean
    try {
        Runtime.getRuntime().exec(getString(com.enabledaonsoft.thecampnew.R.string.root_check_09))
        flag = true
    } catch (e: Exception) {
        flag = false
    }

    return flag
}

saveFileProcess

디바이스에 사을 저장한다.

fun WebView.saveFileProcess(res: Response<ResponseBody>, name: String) : Observable<File> {
    return Observable.create { subscriber ->
        try {
            //val header = res.headers()["Content-Disposition"]
            val fileName = name.replace(".", "")
            val filePath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/" + Environment.DIRECTORY_PICTURES + "/THECAMP"
            val storeDir: File = File(filePath)
            if(!storeDir.exists()){
                storeDir.mkdir()
            }
            val image = File.createTempFile(fileName, ".jpg", storeDir)
            val bufferedSink = Okio.buffer(Okio.sink(image))
            bufferedSink.writeAll(res.body()?.source())
            bufferedSink.close()

            //Log.i(TAG, Thread.currentThread().name)
            //Thread.sleep(5000)

            subscriber.onNext(image)
            subscriber.onComplete()
        }catch(e: IOException){
            Log.e(TAG, e.message)
            subscriber.onError(e)
        }
    }
}

showSoftKeyboard

keyboard를 보여준다

fun showSoftKeyboard(context: Context, view: View) {
    try {
        val inputManager = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        inputManager.showSoftInput(view, 0)
    } catch (e: Exception) {
        e.printStackTrace()
    }

}

hideSoftKeyboard

keyboard를 숨긴다.

fun hideSoftKeyboard(context: Context, view: View) {
    try {
        val inputManager = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        inputManager.hideSoftInputFromWindow(view.windowToken, 0)
    } catch (e: Exception) {
        e.printStackTrace()
    }

}

E1642LocalNumber

전화번호를 - 을 넣어 포매팅한다.

fun E1642LocalNumeber(e164Number: String): String {
    var strResult = e164Number
    try {

        val phoneUtil = PhoneNumberUtil.getInstance()
        val koreaNumberProto = phoneUtil.parse(e164Number, "KR")
        strResult = phoneUtil.format(koreaNumberProto, PhoneNumberUtil.PhoneNumberFormat.NATIONAL)

    } catch (e: NumberParseException) {
        e.printStackTrace()
    }

    return strResult
}

getMakingPhoneNumFromPhoneNum

휴대폰 번호 뒷자리를 마스킹한다.

fun getMakingPhoneNumFromPhoneNum(strOrgPhoneNum: String): String {
    var strOrgPhoneNum = strOrgPhoneNum
    val strMaskNumberPrefix = "### - #### - "
    var strMaskNumber = ""
    try {


        Log.d(TAG, "[StringUtil] getMakingPhoneNumFromPhoneNum strOrgPhoneNum:$strOrgPhoneNum")

        if (TextUtils.isEmpty(strOrgPhoneNum))
            return ""


        strOrgPhoneNum = strOrgPhoneNum.trim { it <= ' ' }
        val nOrgLength = strOrgPhoneNum.length

        if (nOrgLength <= 4)
            strMaskNumber = strMaskNumberPrefix + strOrgPhoneNum
        else {
            strMaskNumber = strMaskNumberPrefix + strOrgPhoneNum.substring(nOrgLength - 4, nOrgLength)
        }

    } catch (e: Exception) {
        e.printStackTrace()
    }

    return strMaskNumber
}

KoreanChar

뭔지 모르겠음

class KoreanChar(private val _value: Char, private val _useCompatibilityJamo: Boolean) {

    val choseong: Char
        get() {
            val index = _value.toInt() - HANGUL_SYLLABLES_BASE
            val choseongIndex = index / (JUNGSEONG_COUNT * JONGSEONG_COUNT)
            return if (_useCompatibilityJamo)
                compatibilityChoseong[choseongIndex].toChar()
            else
                (choseongIndex + 0x1100).toChar()
        }

    companion object {
        internal val CHOSEONG_COUNT = 19
        internal val JUNGSEONG_COUNT = 21
        internal val JONGSEONG_COUNT = 28
        internal val HANGUL_SYLLABLE_COUNT = CHOSEONG_COUNT * JUNGSEONG_COUNT * JONGSEONG_COUNT
        internal val HANGUL_SYLLABLES_BASE = 0xAC00
        internal val HANGUL_SYLLABLES_END = HANGUL_SYLLABLES_BASE + HANGUL_SYLLABLE_COUNT
        internal val compatibilityChoseong = intArrayOf(
            0x3131,
            0x3132,
            0x3134,
            0x3137,
            0x3138,
            0x3139,
            0x3141,
            0x3142,
            0x3143,
            0x3145,
            0x3146,
            0x3147,
            0x3148,
            0x3149,
            0x314A,
            0x314B,
            0x314C,
            0x314D,
            0x314E
        )


        val HANGUL_BEGIN_UNICODE = 44032
        val HANGUL_BASE_UNIT = 588
        val HANGUL_END_UNICODE = 55203
        val INITIAL_SOUND_UNICODE = intArrayOf(
            12593,
            12594,
            12596,
            12599,
            12600,
            12601,
            12609,
            12610,
            12611,
            12613,
            12614,
            12615,
            12616,
            12617,
            12618,
            12619,
            12620,
            12621,
            12622
        )
        val INITIAL_SOUND =
            charArrayOf(
                'ㄱ',
                'ㄲ',
                'ㄴ',
                'ㄷ',
                'ㄸ',
                'ㄹ',
                'ㅁ',
                'ㅂ',
                'ㅃ',
                'ㅅ',
                'ㅆ',
                'ㅇ',
                'ㅈ',
                'ㅉ',
                'ㅊ',
                'ㅋ',
                'ㅌ',
                'ㅍ',
                'ㅎ'
            )

        fun isHangulChoseong(c: Char): Boolean {
            return 0x1100 <= c.toInt() && c.toInt() <= 0x1112
        }

        fun isHangulCompatibilityChoseong(c: Char): Boolean {
            return 0x3131 <= c.toInt() && c.toInt() <= 0x314E
        }

        fun isHangulSyllable(c: Char): Boolean {
            return HANGUL_SYLLABLES_BASE <= c.toInt() && c.toInt() < HANGUL_SYLLABLES_END
        }


        fun getHangulInitialSound(value: String): String {
            val result = StringBuffer()
            val unicodeList = convertStringToUnicode(value)
            for (unicode in unicodeList!!) {
                if (HANGUL_BEGIN_UNICODE <= unicode && unicode <= HANGUL_END_UNICODE) {
                    val tmp = unicode - HANGUL_BEGIN_UNICODE
                    val index = tmp / HANGUL_BASE_UNIT
                    result.append(INITIAL_SOUND[index])
                } else {
                    result.append(convertUnicodeToChar(unicode))
                }
            }
            return result.toString()
        }

        fun convertStringToUnicode(str: String?): IntArray? {
            var unicodeList: IntArray? = null
            if (str != null) {
                unicodeList = IntArray(str.length)
                for (i in 0 until str.length) {
                    unicodeList[i] = convertCharToUnicode(str[i])
                }
            }
            return unicodeList
        }

        fun convertCharToUnicode(ch: Char): Int {
            return ch.toInt()
        }


        /**
         * 유니코드(16진수)를 문자로 변환 후 반환 한다.
         *
         * @param hexUnicode
         * @return
         */
        fun convertUnicodeToChar(hexUnicode: String): Char {
            return Integer.parseInt(hexUnicode, 16).toChar()
        }

        /**
         * 유니코드(10진수)를 문자로 변환 후 반환 한다.
         *
         * @param unicode
         * @return
         */
        fun convertUnicodeToChar(unicode: Int): Char {
            return convertUnicodeToChar(toHexString(unicode))
        }

        private fun toHexString(decimal: Int): String {
            val intDec = java.lang.Long.valueOf(decimal.toLong())
            return java.lang.Long.toHexString(intDec)
        }
    }
}

PreviousAPIManager NextDeviceInfoUtils

Last updated 5 years ago

Was this helpful?