11. (TWOK/UTIL) [Android/Java] C_Util - string, 날짜, 빌드 정보, 모바일 제어, 형 변환 등 유틸 파일 클래스

---

[설 명]

​

프로그램 : Android / Java

​

설 명 : string, 날짜, 빌드 정보, 모바일 제어, 형 변환 등 유틸 파일 클래스

 

---

[소스 코드]

 

package com.example.testapp;

import static android.content.Context.CLIPBOARD_SERVICE;

import android.app.ActivityManager;
import android.app.AlertDialog;
import android.app.NotificationManager;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.Signature;
import android.media.Ringtone;
import android.media.RingtoneManager;
import android.net.Uri;
import android.os.Build;
import android.os.PowerManager;
import android.os.Vibrator;
import android.provider.Settings;
import android.text.Html;
import android.util.Base64;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Display;
import android.view.WindowManager;
import android.widget.Toast;

import org.json.JSONObject;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class C_Util {


    /**
     * TODO [클래스 설명]
     * // -----------------------------------------
     * 1. 프로그램 상 필요한 유틸 파일 모음 클래스
     * // -----------------------------------------
     * 2. [RETURN] getNowDateTime24 : 24 시간 형태 현재 날짜 확인 : 2022.03.21 14:34:20 월요일
     * // -----------------------------------------
     * 3. [RETURN] getNowDateTime24Number : 24 시간 형태 현재 날짜 확인 : 20220321143420
     * // -----------------------------------------
     * 4. [VOID] showMobileBuildInfo : 모바일 빌드 정보 확인 실시
     * // -----------------------------------------
     * 5. [RETURN] getMobileCode : 모바일 버전 코드 확인 : (ex : 1)
     * // -----------------------------------------
     * 6. [RETURN] getMobileVersion : 모바일 버전명 확인 : (ex : 1.0.0)
     * // -----------------------------------------
     * 7. [RETURN] getMobilePackageName : 애플리케이션 패키지명 확인 : com.test.app
     * // -----------------------------------------
     * 8. [VOID] callDisplayWakeUp : 모바일 디스플레이 화면 강제 기상
     * // -----------------------------------------
     * 9. [VOID] callVibrator : 모바일 진동 발생
     * // -----------------------------------------
     * 10. [VOID] callRingtoneSound() : 모바일 기본 알림을 발생
     * // -----------------------------------------
     * 11. [VOID] removeBadge : 노티피케이션 뱃지 지우기 [특정 아이디 / 전체]
     * // -----------------------------------------
     * 12. [RETURN] getMobileSize : 모바일 화면 크기 구하기 DP : W / S / M / L / LX / NO
     * // -----------------------------------------
     * 13. [RETURN] convert_HexString_To_Byte : 헥사 문자열 데이터를 바이트 배열로 반환 실시 : byte array
     * // -----------------------------------------
     * 14. [RETURN] convert_ByteArray_To_HexString : 바이트 배열 데이터를 헥사 문자열로 반환 실시 : 01 02 AB
     * // -----------------------------------------
     * 15. [RETURN] matchString : 정규식 수행 메소드 : 공백 및 특수 문자 제거 문자열
     * // -----------------------------------------
     * 16. [RETURN] HexUtil_To_ByteArray : 헥사 문자열 데이터를 바이트 배열로 반환 실시 : byte array
     * // -----------------------------------------
     * 17. [RETURN] getDateMinus : 두 날짜 차이 계산 수행 : 분, 초 int 형 반환
     * // -----------------------------------------
     * 18. [RETURN] getNowUseActivity : 현재 실행 중인 최상위 액티비티 명 확인 : 클래스 명 반환
     * // -----------------------------------------
     * 19. [RETURN] getTimeStamp_To_Date : 타임 스탬프에서 Date 24시간 날짜 형식으로 변환 실시 : 20220321143420
     * // -----------------------------------------
     * 20. [RETURN] stringNotNull : String 문자열 데이터 널 판단 실시 : true / false
     * // -----------------------------------------
     * 21. [RETURN] stringMultiContains : String 문자열 다중 contains 문자 포함 확인 실시 : true / false
     * // -----------------------------------------
     * 22. [RETURN] stringJsonObjectEnable : String 문자열 데이터를 Json Object 형식으로 변경 가능 한지 체크 실시 : true / false
     * // -----------------------------------------
     * 23. [RETURN] arrayListStringToArrayList : 배열 형식 String 문자열 데이터를 ArrayList 로 반환 실시
     * // -----------------------------------------
     * 24. [RETURN] htmlTagRemoveString : html 형식 태그 제거 문자열 데이터 반환
     * // -----------------------------------------
     * 25. [RETURN] htmlTagRemoveString_2 : html 형식 태그 제거 문자열 데이터 반환
     * // -----------------------------------------
     * 26. [RETURN] stringToByte : string 문자열 데이터를 byte 배열 값으로 반환 수행
     * // -----------------------------------------
     * 27. [RETURN] byteToString : byte 배열 값을 string 문자열 데이터로 반환
     * // -----------------------------------------
     * 28. [RETURN] stringCount : string 문자열 데이터에서 특정 문자 개수 카운트 반환
     * // -----------------------------------------
     * 29. [RETURN] removeArrayOverlap : ArrayList 배열 중복 데이터 제거 실시
     * // -----------------------------------------
     * 30. [RETURN] stringIsNumber : string 문자열 데이터 모두 정수 구성 여부 확인
     * // -----------------------------------------
     * 31. [RETURN] doubleCutLength : Double 소수점 데이터를 특정 소수점 자릿수 기준으로 자르기 실시 [반올림 없음]
     * // -----------------------------------------
     * 32. [RETURN] arraySubList : subList 사용해 array list 가변 배열 데이터 부분 데이터 반환 실시
     * // -----------------------------------------
     * 33. [RETURN] arrayIntersect : ArrayList 배열 데이터 교집합 수행 실시
     * // -----------------------------------------
     * 34. [RETURN] urlFileExtensionName : URL 주소 파일 확장자 포함 확인 실시
     * // -----------------------------------------
     * 35. [VOID] appDownloadFile : 다운로드 매니저 사용해 파일 다운로드 수행
     * // -----------------------------------------
     * 36. [RETURN] LPAD : 왼쪽 기준 부족한 데이터 채우기 실시
     * // -----------------------------------------
     * 37. [RETURN] RPAD : 오른쪽 기준 부족한 데이터 채우기 실시
     * // -----------------------------------------
     * 38. [RETURN] startRemoveChar : 시작 기준 특정 문자 지우기 실시
     * // -----------------------------------------
     * 39. [RETURN] endRemoveChar : 종료 기준 특정 문자 지우기 실시
     * // -----------------------------------------
     * 40. [RETURN] getDeviceOsVersion : 디바이스 소프트웨어 OS 정보 확인
     * // -----------------------------------------
     * 41. [RETURN] stringIsUrlParsing : string 문자열 url 주소 형식으로 변경 가능한지 체크 실시
     * // -----------------------------------------
     * 42. [RETURN] getTimeStamp : 현재 날짜 및 시간 밀리세컨드 13자리 타임스탬프 값 반환
     * // -----------------------------------------
     * 43. [VOID] clearAppCache : 앱 캐시 초기화 실시 
     * // -----------------------------------------
     * 44. [VOID] clearAppData : 앱 캐시 및 데이터 초기화 실시 
     * // -----------------------------------------
     * 45. [RETURN] getDeviceModelName : 실제 디바이스 기기 모델 이름 명칭 확인
     * // -----------------------------------------
     * */





    // TODO [빠른 로직 찾기 : 주석 로직 찾기]
    /**
     * // -----------------------------------------
     * // [SEARCH FAST] : []
     * // -----------------------------------------
     */





    // TODO [24 시간 형태 현재 날짜 확인]
    public static String getNowDateTime24() {

        /**
         * // -----------------------------------------
         * [getNowDateTime24 메소드 설명]
         * // -----------------------------------------
         * 1. 24 시간 형태 현재 날짜 확인 수행 메소드
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.getNowDateTime24();
         * // -----------------------------------------
         * 3. 리턴 데이터 : 2022.03.21 14:34:20 월요일
         * // -----------------------------------------
         * */

        // [날짜 데이터 확인 실시]
        long time = System.currentTimeMillis();
        SimpleDateFormat dayTime = new SimpleDateFormat("yyyy.MM.dd kk:mm:ss E요일");
        String str = dayTime.format(new Date(time));

        // [로그 출력]
        /*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> getNowDateTime24() :: 24 시간 형태 현재 날짜 확인]");
        Log.i("","\n"+"[날짜 :: "+String.valueOf(str)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return str;
    }





    // TODO [24 시간 형태 현재 날짜 확인]
    public static String getNowDateTime24Number() {

        /**
         * // -----------------------------------------
         * [getNowDateTime24Number 메소드 설명]
         * // -----------------------------------------
         * 1. 24 시간 형태 현재 날짜 확인 수행 메소드
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.getNowDateTime24Number();
         * // -----------------------------------------
         * 3. 리턴 데이터 : 20220321143420
         * // -----------------------------------------
         * */

        // [날짜 데이터 확인 실시]
        long time = System.currentTimeMillis();
        SimpleDateFormat dayTime = new SimpleDateFormat("yyyyMMddkkmmss");
        String str = dayTime.format(new Date(time));

        // [로그 출력]
        /*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> getNowDateTime24Number() :: 24 시간 형태 현재 날짜 확인]");
        Log.i("","\n"+"[날짜 :: "+String.valueOf(str)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return str;
    }





    // TODO [모바일 빌드 정보 확인]
    public static void showMobileBuildInfo(Context mContext) {

        /**
         * // -----------------------------------------
         * [showMobileBuildInfo 메소드 설명]
         * // -----------------------------------------
         * 1. 모바일 빌드 정보 확인 수행 메소드
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.showMobileBuildInfo(A_Main.this);
         * // -----------------------------------------
         * */

        try {
            Log.i("---","---");
            Log.d("//===========//","================================================");

            // [고유 단말기 정보 확인]
            Log.i("","\n"+"[C_Util >> showMobileBuildInfo() :: 모바일 빌드 정보 확인]");
            Log.i("","\n"+"["+"BRAND :: "+String.valueOf(Build.BRAND)+"]");
            Log.i("","\n"+"["+"MODEL :: "+String.valueOf(Build.MODEL)+"]");
            Log.i("","\n"+"["+"MANUFACTURER :: "+String.valueOf(Build.MANUFACTURER)+"]");
            Log.i("","\n"+"["+"BOARD :: "+String.valueOf(Build.BOARD)+"]");
            Log.i("","\n"+"["+"ID - "+String.valueOf(Build.ID)+"]");
            Log.i("","\n"+"["+"BOOTLOADER :: "+String.valueOf(Build.BOOTLOADER)+"]");
            Log.i("","\n"+"["+"DEVICE :: "+String.valueOf(Build.DEVICE)+"]");
            Log.i("","\n"+"["+"DISPLAY :: "+String.valueOf(Build.DISPLAY)+"]");
            Log.i("","\n"+"["+"HARDWARE :: "+String.valueOf(Build.HARDWARE)+"]");
            Log.i("","\n"+"["+"HOST :: "+String.valueOf(Build.HOST)+"]");
            Log.i("","\n"+"["+"PRODUCT :: "+String.valueOf(Build.PRODUCT)+"]");
            Log.i("","\n"+"["+"TYPE :: "+String.valueOf(Build.TYPE)+"]");
            Log.i("","\n"+"["+"USER :: "+String.valueOf(Build.USER)+"]");
            Log.i("","\n"+"["+"TAGS :: "+String.valueOf(Build.TAGS)+"]");
            Log.i("","\n"+"["+"TIME :: "+String.valueOf(Build.TIME)+"]");
            Log.i("","\n"+"-"+""+""+"-");

            // [안드로이드 APK 파일 정보 확인]
            PackageInfo pi = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0);
            Log.i("","\n"+"["+"versionName :: "+String.valueOf(pi.versionName)+"]");
            Log.i("","\n"+"["+"versionCode :: "+String.valueOf(pi.versionCode)+"]");
            Log.i("","\n"+"-"+""+""+"-");

            // [패키지명 확인]
            Log.i("","\n"+"["+"getPackageName :: "+String.valueOf(mContext.getPackageName())+"]");
            Log.i("","\n"+"["+"getPackage :: "+String.valueOf(mContext.getClass().getPackage().getName().trim())+"]");
            Log.i("","\n"+"-"+""+""+"-");

            // [현재 실행 중인 클래스 명 확인]
            ActivityManager manager = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
            List<ActivityManager.RunningTaskInfo> info = manager.getRunningTasks(1);
            ComponentName componentName = info.get(0).topActivity;
            String ActivityName = String.valueOf(componentName.getShortClassName().substring(1));
            Log.i("","\n"+"["+"ActivityName :: "+String.valueOf(ActivityName)+"]");
            Log.i("","\n"+"["+"getComponentName :: "+String.valueOf(mContext.getPackageName())+"]");
            Log.d("//===========//","================================================");
            Log.i("---","---");
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
    }





    // TODO [모바일 버전 코드 확인]
    public static String getMobileCode(Context mContext) {

        /**
         * // -----------------------------------------
         * [getMobileCode 메소드 설명]
         * // -----------------------------------------
         * 1. 모바일 버전 코드 확인 (ex : 1)
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.getMobileCode(A_Main.this);
         * // -----------------------------------------
         * 3. 리턴 데이터 : 1
         * // -----------------------------------------
         * */

        String returnData = "";
        try {
            // [빌드 버전 코드 : ex) 1]
            PackageInfo pi = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0);
            returnData = String.valueOf(pi.versionCode);
            Log.i("---","---");
            Log.d("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> getMobileCode() :: 모바일 버전 코드 확인]");
            Log.i("","\n"+"[code :: "+String.valueOf(returnData)+"]");
            Log.d("//===========//","================================================");
            Log.i("---","---");
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return returnData;
    }





    // TODO [모바일 버전명 확인]
    public static String getMobileVersion(Context mContext) {

        /**
         * // -----------------------------------------
         * [getMobileVersion 메소드 설명]
         * // -----------------------------------------
         * 1. 모바일 버전명 확인 (ex : 1.0.0)
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.getMobileVersion(A_Main.this);
         * // -----------------------------------------
         * 3. 리턴 데이터 : 1.0.0
         * // -----------------------------------------
         * */

        String returnData = "";
        try {
            // [빌드 버전명 : ex) 1.0.0]
            PackageInfo pi = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0);
            returnData = String.valueOf(pi.versionName);
            Log.i("---","---");
            Log.d("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> getMobileVersion() :: 모바일 버전명 확인]");
            Log.i("","\n"+"[version :: "+String.valueOf(returnData)+"]");
            Log.d("//===========//","================================================");
            Log.i("---","---");
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return returnData;
    }





    // TODO [애플리케이션 패키지명 확인]
    public static String getMobilePackageName(Context mContext) {

        /**
         * // -----------------------------------------
         * [getMobilePackageName 메소드 설명]
         * // -----------------------------------------
         * 1. 애플리케이션 패키지명 확인
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.getMobilePackageName(A_Main.this);
         * // -----------------------------------------
         * 3. 리턴 데이터 : com.test.app
         * // -----------------------------------------
         * */

        String returnData = "";
        try {
            // [패키지 명칭 : ex) com.test.app]
            PackageInfo pi = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0);
            returnData = String.valueOf(mContext.getPackageName().trim());
            Log.i("---","---");
            Log.d("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> getMobilePackageName() :: 애플리케이션 패키지명 확인]");
            Log.i("","\n"+"[package :: "+String.valueOf(returnData)+"]");
            Log.d("//===========//","================================================");
            Log.i("---","---");
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return returnData;
    }





    // TODO [모바일 디스플레이 화면 강제 기상 깨우기]
    public static void callDisplayWakeUp(Context mContext){

        /**
         * // -----------------------------------------
         * [callDisplayWakeUp 메소드 설명]
         * // -----------------------------------------
         * 1. 모바일 디스플레이 화면 강제 기상 깨우기 수행 메소드
         * // -----------------------------------------
         * 2. 필요 퍼미션 :
         *   - <uses-permission android:name="android.permission.WAKE_LOCK"/>
         * // -----------------------------------------
         * 3. 호출 방법 : C_Util.callDisplayWakeUp(A_Main.this);
         * // -----------------------------------------
         * */

        try {
            Log.i("---","---");
            Log.d("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> callDisplayWakeUp() :: 모바일 디스플레이 화면 강제 기상 실시]");
            Log.d("//===========//","================================================");
            Log.i("---","---");
            PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
            PowerManager.WakeLock wakelock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP, "My:Tag");
            wakelock.acquire(); // [화면 즉시 기상 실시]
            wakelock.release(); // [WakeLock 자원 해제]
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }





    // TODO [모바일 진동 발생 시키는 메소드]
    public static void callVibrator(Context mContext){

        /**
         * // -----------------------------------------
         * [callVibrator 메소드 설명]
         * // -----------------------------------------
         * 1. 모바일 진동 발생 수행 메소드
         * // -----------------------------------------
         * 2. 필요 퍼미션 :
         *   - <uses-permission android:name="android.permission.VIBRATE" />
         * // -----------------------------------------
         * 3. 호출 방법 : C_Util.callVibrator(A_Main.this);
         * // -----------------------------------------
         * */

        try {
            Log.i("---","---");
            Log.d("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> callVibrator() :: 모바일 진동 발생 실시]");
            Log.d("//===========//","================================================");
            Log.i("---","---");
            Vibrator vibrator = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE);
            vibrator.vibrate(1000); // miliSecond [지정한 시간동안 진동 / 1000 = 1초]
        }
        catch (Exception e){
            //e.printStackTrace();
        }
    }





    // TODO [모바일 기본 알림을 발생 시키는 메소드]
    public static void callRingtoneSound(Context mContext){

        /**
         * // -----------------------------------------
         * [callRingtoneSound 메소드 설명]
         * // -----------------------------------------
         * 1. 모바일 기본 알림음 수행 메소드
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.callRingtoneSound(A_Main.this);
         * // -----------------------------------------
         * */

        try {
            Log.i("---","---");
            Log.d("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> callRingtoneSound() :: 모바일 기본 알림을 발생 실시]");
            Log.d("//===========//","================================================");
            Log.i("---","---");
            Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
            Ringtone ringtone = RingtoneManager.getRingtone(mContext, defaultSoundUri);
            ringtone.play();
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }





    // TODO [노티피케이션 뱃지 지우기 메소드]
    public static void removeBadge(Context mContext, int cancleID){

        /**
         * // -----------------------------------------
         * [removeBadge 메소드 설명]
         * // -----------------------------------------
         * 1. 노티피케이션 뱃지 지우기 메소드 [특정 아이디 지움 / 전체 지움]
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.removeBadge(A_Main.this, 1);
         * // -----------------------------------------
         * */

        try {
            Log.i("---","---");
            Log.d("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> removeBadge() :: 노티피케이션 뱃지 지우기 실시]");
            Log.i("","\n"+"[cancleID :: "+String.valueOf(cancleID)+"]");
            Log.d("//===========//","================================================");
            Log.i("---","---");
            NotificationManager notificationManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
            notificationManager.cancel(cancleID); // 캔슬 부분에 적힌 것이 노티피케이션 활성 id 값
            notificationManager.cancelAll();
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }





    // TODO [모바일 화면 크기 구하기 dp 사이즈]
    public static String getMobileSize(Context mContext){

        /**
         * // -----------------------------------------
         * [getMobileSize 메소드 설명]
         * // -----------------------------------------
         * 1. 모바일 화면 크기 구하기 dp 사이즈
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.getMobileSize(A_Main.this);
         * // -----------------------------------------
         * 3. 리턴 데이터 : W / S / M / L / XL / NO
         * // -----------------------------------------
         * */

        String size = "";
        try {
            Display display = ((WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
            DisplayMetrics outMetrics = new DisplayMetrics ();
            display.getMetrics(outMetrics);
            float density = mContext.getResources().getDisplayMetrics().density;
            float dpHeight = outMetrics.heightPixels / density;
            float dpWidth = outMetrics.widthPixels / density;

            int dpWidthValue = (int)dpWidth;
            int dpHeightValue = (int)dpHeight;

            /**
             *    [장치]   [가로]   [세로]
             * 1) Watch =  250dp    250dp
             * 2) mobile = 320dp    569dp (s6)
             * 3) mobile = 400dp    730dp (note 5)
             * 4) mobile = 400dp    810dp (note 10 / LG Q9)
             * 5) mobile = 800dp    1280dp (Tab)
             * 6) Tablet = 960dp    600dp (Tab)
             *             1280dp   800dp
             */

            if(dpHeightValue < 320){ //0 ~ 319
                size = "W";
            }
            else if(dpHeightValue < 660){ //320 ~ 659
                size = "S";
            }
            else if(dpHeightValue < 750){ //660 ~ 749
                size = "M";
            }
            else if(dpHeightValue < 900){ //750 ~ 899
                size = "L";
            }
            else if(dpHeightValue < 1600){ //900 ~ 1599
                size = "XL";
            }
            else{
                size = "NO";
            }
            Log.i("---","---");
            Log.d("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> getMobileSize() :: 모바일 화면 크기 구하기 DP]");
            Log.i("","\n"+"["+"디바이스 :: "+String.valueOf("Android")+"]");
            Log.i("","\n"+"["+"Android OS :: "+String.valueOf(Build.VERSION.RELEASE)+"]");
            Log.i("","\n"+"["+"모델 :: "+String.valueOf(Build.MODEL)+"]");
            Log.i("","\n"+"["+"제조사 :: "+String.valueOf(Build.MANUFACTURER)+"]");
            Log.i("","\n"+"["+"가로 (DP) :: "+String.valueOf(dpWidthValue)+"]");
            Log.i("","\n"+"["+"세로 (DP) :: "+String.valueOf(dpHeightValue)+"]");
            Log.i("","\n"+"["+"화면 사이즈 :: "+String.valueOf(size)+"]");
            Log.d("//===========//","================================================");
            Log.i("---","---");
        }
        catch (Exception e){
            e.printStackTrace();
        }
        return size;
    }





    // TODO [헥사 문자열 값을 바이트 배열로 변환 수행 메소드 : Hex String convert byte array]
    public static byte[] convert_HexString_To_Byte(String data) {

        /**
         * // -----------------------------------------
         * [convert_HexString_To_Byte 메소드 설명]
         * // -----------------------------------------
         * 1. 헥사 문자열 값을 바이트 배열로 변환 수행 메소드
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.convert_HexString_To_Byte("0123456789abcdef0123456789abcdef");
         * // -----------------------------------------
         * 3. 리턴 데이터 : byte array 배열
         * // -----------------------------------------
         * */

        String hex = data.replaceAll("0x", ""); //0x문자 제거
        String hex2 = hex.replaceAll("0X", ""); //0x문자 제거
        String Trim = hex2.replaceAll(" ", ""); //공백문자 제거

        byte arr[] = new byte[Trim.length()/2]; // (전체 문자열 길이 / 2) 만큼 배열 생성
        int before = 0;
        int after = 2;
        for(int i=0; i<arr.length; i++) {
            String value = Trim.substring(before, after); //2글자씩 잘라서 데이터 출력
            arr[i] = new java.math.BigInteger(value, 16).byteValue(); //BigInteger사용해 hexString > byte 변환
            // [다음 2글자씩 또 변환하기 위함]
            before += 2;
            after += 2;
        }

        // [로그 출력]
        /*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> convert_HexString_To_Byte() :: Hex String convert byte array]");
        Log.i("","\n"+"["+"input :: "+String.valueOf(data)+"]");
        Log.i("","\n"+"["+"return :: "+ Arrays.toString(arr) +"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환]
        return arr;
    }





    // TODO [바이트 배열 값을 헥사 문자열 값으로 변환 : byte array convert Hex String]
    public static String convert_ByteArray_To_HexString(byte buf[]) {

        /**
         * // -----------------------------------------
         * [convert_ByteArray_To_HexString 메소드 설명]
         * // -----------------------------------------
         * 1. 바이트 배열 값을 헥사 문자열 값으로 변환 수행 메소드
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.convert_ByteArray_To_HexString(new byte[] {1, 35, 69, 103, -119, -85, -51, -17, 1, 35, 69, 103, -119, -85, -51, -17} );
         * // -----------------------------------------
         * 3. 리턴 데이터 : 헥사 문자열 데이터
         * // -----------------------------------------
         * */

        String Hex_Value = "";
        for(int i=0; i<buf.length; i++) {
            //Hex_Value += String.format("0x%02x ", buf[i]); // [0xfg]
            //Hex_Value += String.format("%02x ", buf[i]); // [fg]

            //Hex_Value += String.format("0X%02X ", buf[i]); // [0XFG]
            Hex_Value += String.format("%02X ", buf[i]); // [FG]
        }

        // [로그 출력]
        /*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> convert_ByteArray_To_HexString() :: byte array convert Hex String]");
        Log.i("","\n"+"["+"input :: "+ Arrays.toString(buf) +"]");
        Log.i("","\n"+"["+"return :: "+String.valueOf(Hex_Value)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 반환]
        return Hex_Value;
    }





    // TODO [정규식 수행 메소드]
    public static String matchString(String value) {

        /**
         * // -----------------------------------------
         * [matchString 메소드 설명]
         * // -----------------------------------------
         * 1. 정규식 수행 메소드 [공백 및 특수문자 제거]
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.matchString("hello@@TwoK");
         * // -----------------------------------------
         * 3. 리턴 데이터 : 공백 및 특수문자 제거 데이터 반환
         * // -----------------------------------------
         * */

        /**
         * // -----------------------------------------
         * [요약 설명]
         * // -----------------------------------------
         * 1. 정규식 패턴 ^[a-z] : 영어 소문자 허용
         * // -----------------------------------------
         * 2. 정규식 패턴 ^[A-Z] : 영어 대문자 허용
         * // -----------------------------------------
         * 3. 정규식 패턴 ^[ㄱ-ㅎㅏ-ㅣ가-힣] : 한글 허용
         * // -----------------------------------------
         * 4. 정규식 패턴 ^[ㄱ-ㅎㅏ-ㅣ가-힣] : 숫자 허용
         * // -----------------------------------------
         * 5. 정규식 패턴 ^[ ] or ^[\\s] : 공백 허용
         * // -----------------------------------------
         */

        // [결과를 반환할 변수 선언 실시]
        String result = "";

        // [정규식 패턴 형식 정의]
        String pattern = "^[ㄱ-ㅎㅏ-ㅣ가-힣a-zA-Z0-9]"; // 정규식 : 한글, 영어, 숫자만 허용 (공백, 특수문자 제거)
        //String pattern = "^[ㄱ-ㅎㅏ-ㅣ가-힣a-zA-Z0-9\\s]"; // 정규식 : 한글, 영어, 숫자, 공백만 허용 (특수문자 제거)

        if (value != null && value.length() > 0 && value.trim().equals("") == false) { // 문자열 길이가 1개 이상인 경우
            // for 반복문을 선언해서 문자 한글자씩 확인 실시
            for(int i=0; i<value.length(); i++) {
                if (String.valueOf(value.charAt(i)).matches(pattern)) { // 정규식 패턴을 만족하는 경우
                    result += value.charAt(i); // 문자열 추가
                }
                else { // 정규식 패턴이 아닌 경우
                    continue;
                }
            }
        }
        else { // 문자열 길이가 0개인 경우
            result = String.valueOf(value); // 인풋값 그대로 반환
        }

        // 결과 반환 실시
        return result;
    }





    // TODO [헥사 문자열 값을 바이트 배열로 반환 메소드 : Hex String convert byte array]
    public static byte[] HexUtil_To_ByteArray(String data) {

        /**
         * // -----------------------------------------
         * [HexUtil_To_ByteArray 메소드 설명]
         * // -----------------------------------------
         * 1. 헥사 문자열 값을 바이트 배열로 반환 메소드
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.HexUtil_To_ByteArray("0123456789abcdef0123456789abcdef");
         * // -----------------------------------------
         * 3. 리턴 데이터 : 바이트 배열 반환 실시
         * // -----------------------------------------
         * */

        byte[] temp = new byte[data.length() / 2];
        for(int i = 0; i < data.length() / 2; ++i) {
            temp[i] = toByte(data.substring(i * 2, i * 2 + 2));
        }
        return temp;
    }
    public static byte toByte(String hexStr) {
        byte result = 0;
        String hex = hexStr.toUpperCase();
        for(int i = 0; i < hex.length(); ++i) {
            char c = hex.charAt(hex.length() - i - 1);
            byte b = toByte(c);
            result = (byte)(result | (b & 15) << i * 4);
        }
        return result;
    }
    private static byte toByte(char c) {
        switch(c) {
            case '0':
                return 0;
            case '1':
                return 1;
            case '2':
                return 2;
            case '3':
                return 3;
            case '4':
                return 4;
            case '5':
                return 5;
            case '6':
                return 6;
            case '7':
                return 7;
            case '8':
                return 8;
            case '9':
                return 9;
            case ':':
            case ';':
            case '<':
            case '=':
            case '>':
            case '?':
            case '@':
            default:
                return 0;
            case 'A':
                return 10;
            case 'B':
                return 11;
            case 'C':
                return 12;
            case 'D':
                return 13;
            case 'E':
                return 14;
            case 'F':
                return 15;
        }
    }




    
    // TODO [두 날짜 차이 계산 수행 실시]
    public static int getDateMinus(String bigDate, String smallDate) {

        /**
         * // -----------------------------------------
         * // [getDateMinus 메소드 설명]
         * // -----------------------------------------
         * 1. 날짜 형식 : yyyyMMddkkmmss 24시간 형태로 구성
         * // -----------------------------------------
         * 2. bigDate 큰 날짜 - smallDate 작은 날짜 연산 수행
         * // -----------------------------------------
         * 3. 리턴 형식 : 초 , 분 , 시간 , 일자 단위 선택 (int 형 반환)
         * // -----------------------------------------
         * 4. 인풋 예시 :
         *    - C_Util.getDateMinus("2022 02 10 18 30 15", "2022 02 10 18 30 15"); // 동일
         *
         *    - C_Util.getDateMinus("2022 02 10 18 30 15", "2022 02 10 18 30 10"); // 초 [다름]
         *    - C_Util.getDateMinus("2022 02 10 18 30 15", "2022 02 10 18 25 15"); // 분 [다름]
         *    - C_Util.getDateMinus("2022 02 10 18 30 15", "2022 02 10 17 30 15"); // 시간 [다름]
         *    - C_Util.getDateMinus("2022 02 10 18 30 15", "2022 02 09 18 30 15"); // 일자 [다름]
         *    - C_Util.getDateMinus("2022 02 10 18 30 15", "2022 01 10 18 30 15"); // 월 [다름]
         *    - C_Util.getDateMinus("2022 02 10 18 30 15", "2021 02 10 18 30 15"); // 연도 [다름]
         * // -----------------------------------------
         * */

        // [초기 리턴 데이터 선언]
        int returnData = 0;


        // [인풋으로 들어온 값에 공백이 있는 경우 제거 실시]
        bigDate = bigDate.replaceAll(" ", "");
        smallDate = smallDate.replaceAll(" ", "");


        // [인풋으로 들어온 값 널 데이터 검증 실시]
        try {
            if (bigDate != null && bigDate.length()>0 && !bigDate.equals("") && !bigDate.trim().equals("null")
                    && smallDate != null && smallDate.length()>0 && !smallDate.equals("") && !smallDate.trim().equals("null")){ // [정상 데이터 인 경우]

                // [인풋으로 들어온 데이터가 int 형 인지 검증 수행]
                boolean bigDate_NotNumber = false;
                boolean smallDate_NotNumber = false;

                for(int i=0; i<bigDate.length(); i++) {
                    if(Character.isDigit(bigDate.charAt(i)) == false) { // 숫자가 아닌 경우
                        bigDate_NotNumber = true;
                    }
                }
                for(int j=0; j<smallDate.length(); j++) {
                    if(Character.isDigit(smallDate.charAt(j)) == false) { // 숫자가 아닌 경우
                        smallDate_NotNumber = true;
                    }
                }

                if (bigDate_NotNumber == true || smallDate_NotNumber == true){ // 문자가 포함된 데이터 인 경우
                    Log.i("---","---");
                    Log.e("//===========//","================================================");
                    Log.i("","\n"+"[C_Util >> getDateMinus() :: 두 날짜 차이 계산 에러]");
                    Log.i("","\n"+"[bigDate [인풋 날짜_1] :: "+String.valueOf(bigDate)+"]");
                    Log.i("","\n"+"[smallDate [인풋 날짜_2] :: "+String.valueOf(smallDate)+"]");
                    Log.i("","\n"+"[error [문자 에러] :: "+"비정상 데이터"+"]");
                    Log.e("//===========//","================================================");
                    Log.i("---","---");
                    return returnData;
                }


                // [로직 처리 수행 실시]
                Date bigFormat = new SimpleDateFormat("yyyyMMddkkmmss").parse(bigDate);
                Date smallFormat = new SimpleDateFormat("yyyyMMddkkmmss").parse(smallDate);


                // [초, 분, 시간, 일자 차이 계산 실시 >> long 타입]
                long minusSec = (bigFormat.getTime() - smallFormat.getTime()) / 1000; // [초]
                long minusMin = (bigFormat.getTime() - smallFormat.getTime()) / 60000; // [분]
                long minusHour = (bigFormat.getTime() - smallFormat.getTime()) / 3600000; // [시간]
                long minusDay = minusSec / (24*60*60); // [일자]

                Log.i("---","---");
                Log.w("//===========//","================================================");
                Log.i("","\n"+"[C_Util >> getDateMinus() :: 두 날짜 차이 결과 확인]");
                Log.i("","\n"+"---------------------");
                Log.i("","\n"+"[bigDate [인풋 날짜_1] :: "+String.valueOf(bigDate)+"]");
                Log.i("","\n"+"[smallDate [인풋 날짜_2] :: "+String.valueOf(smallDate)+"]");
                Log.i("","\n"+"---------------------");
                Log.i("","\n"+"[minusSec [초] 차이 :: "+String.valueOf(minusSec)+"]");
                Log.i("","\n"+"---------------------");
                Log.i("","\n"+"[minusMin [분] 차이 :: "+String.valueOf(minusMin)+"]");
                Log.i("","\n"+"---------------------");
                Log.i("","\n"+"[minusHour [시간] 차이 :: "+String.valueOf(minusHour)+"]");
                Log.i("","\n"+"---------------------");
                Log.i("","\n"+"[minusDay [날짜] 차이 :: "+String.valueOf(minusDay)+"]");
                Log.w("//===========//","================================================");
                Log.i("---","---");


                // [리턴하려는 값을 선택 후 결과 반환]
                returnData = (int) minusMin; // [분]
                //returnData = (int) minusSec; // [초]
            }
            else { // [비정상 데이터 인 경우]
                Log.i("---","---");
                Log.e("//===========//","================================================");
                Log.i("","\n"+"[C_Util >> getDateMinus() :: 두 날짜 차이 계산 에러]");
                Log.i("","\n"+"[bigDate [인풋 날짜_1] :: "+String.valueOf(bigDate)+"]");
                Log.i("","\n"+"[smallDate [인풋 날짜_2] :: "+String.valueOf(smallDate)+"]");
                Log.i("","\n"+"[error [널 에러] :: "+"비정상 데이터"+"]");
                Log.e("//===========//","================================================");
                Log.i("---","---");
            }
        }
        catch (Exception e){
            Log.i("---","---");
            Log.e("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> getDateMinus() :: 두 날짜 차이 계산 에러]");
            Log.i("","\n"+"[bigDate [인풋 날짜_1] :: "+String.valueOf(bigDate)+"]");
            Log.i("","\n"+"[smallDate [인풋 날짜_2] :: "+String.valueOf(smallDate)+"]");
            Log.i("","\n"+"[catch [에러] :: "+String.valueOf(e.getMessage())+"]");
            Log.e("//===========//","================================================");
            Log.i("---","---");
        }
        // [리턴 데이터 반환 실시]
        return returnData;
    }





    // TODO [현재 사용중인 최상위 액티비티 명 확인]
    public static String getNowUseActivity(Context mContext){

        /**
         * // -----------------------------------------
         * [getNowUseActivity 메소드 설명]
         * // -----------------------------------------
         * 1. 현재 사용중인 최상위 액티비티 명 확인
         * // -----------------------------------------
         * 2. 호출 방법 : C_Util.getNowUseActivity(A_Main.this);
         * // -----------------------------------------
         * 3. 리턴 데이터 : 현재 실행 중인 액티비티 클래스 명
         * // -----------------------------------------
         * 4. 참고 : [특정 클래스에서 본인 클래스명 확인 방법] : getClass().getName()
         * // -----------------------------------------
         * */

        // [초기 리턴 결과 반환 변수 선언 실시]
        String returnActivityName = "";
        try {
            ActivityManager manager = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);

            String className = "";
            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
                className = String.valueOf(manager.getAppTasks().get(0).getTaskInfo().topActivity.getClassName());
            }
            else {
                List<ActivityManager.RunningTaskInfo> info = manager.getRunningTasks(1);
                ComponentName componentName= info.get(0).topActivity;
                className = componentName.getClassName();
            }
            Log.i("---","---");
            Log.w("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> getNowUseActivity() :: 현재 사용 중인 최상위 액티비티 확인]");
            Log.i("","\n"+"[className :: "+String.valueOf(className)+"]");
            Log.w("//===========//","================================================");
            Log.i("---","---");

            // [리턴 반환 데이터 삽입 실시]
            returnActivityName = className;
        }
        catch (Exception e){
            //e.printStackTrace();
            Log.i("---","---");
            Log.e("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> getNowUseActivity() :: 현재 사용 중인 최상위 액티비티 확인]");
            Log.i("","\n"+"[catch [에러] :: "+String.valueOf(e.getMessage())+"]");
            Log.e("//===========//","================================================");
            Log.i("---","---");
        }

        // [리턴 결과 반환 수행 실시]
        return returnActivityName;
    }





    // TODO [타임 스탬프 값을 날짜 형식으로 변환 실시]
    public static String getTimeStamp_To_Date(Context mContext, String timeStamp){

        /**
         * // -----------------------------------------
         * [getTimeStamp_To_Date 메소드 설명]
         * // -----------------------------------------
         * 1. Timestamp 값은 현재 시간을 milliseconds 단위로 변환하여 보여줍니다
         * // -----------------------------------------
         * 2. 인풋 타임 스탬프 형식 : 1646295046677
         * // -----------------------------------------
         * 3. 리턴 데이터 : 20220321134530 (24 시간 날짜 형식)
         * // -----------------------------------------
         * 4. 타임 스탬프 (밀리세컨드 만드는 형식)
         *   - Timestamp timestamp = new Timestamp(System.currentTimeMillis()); // 현재 날짜
         *   - timestamp.getTime(); // 타임 스탬프 밀리 세컨드
         * // -----------------------------------------
         * */

        // [초기 리턴 결과 반환 변수 선언 실시]
        String returnDate = "";
        try {
            // [인풋 데이터 널 체크 수행 실시]
            if (timeStamp != null && timeStamp.length()>0 && !timeStamp.trim().equals("") && !timeStamp.trim().equals("null")){

                // [타임 스탬프 값 (1646295046677) 을 Date 로 변경]
                Date date = new Date(Long.parseLong(timeStamp));

                // [타임 스탬프 값을 포맷 Date 형식으로 변경]
                SimpleDateFormat sdf = new SimpleDateFormat ("yyyyMMddkkmmss");

                // [결과 출력 실시]
                Log.i("---","---");
                Log.w("//===========//","================================================");
                Log.i("","\n"+"[C_Util >> getTimeStamp_To_Date() :: 타임 스탬프 >> Date 형 변환 실시]");
                Log.i("","\n"+"[타임 스탬프 :: "+String.valueOf(timeStamp)+"]");
                Log.i("","\n"+"[날 짜 :: "+String.valueOf(sdf.format(date))+"]");
                Log.w("//===========//","================================================");
                Log.i("---","---");

                // [리턴 데이터에 날짜 삽입 실시]
                returnDate = String.valueOf(sdf.format(date));
            }
            else {
                Log.i("---","---");
                Log.e("//===========//","================================================");
                Log.i("","\n"+"[C_Util >> getTimeStamp_To_Date() :: 타임 스탬프 >> Date 형 변환 실시]");
                Log.i("","\n"+"[타임 스탬프 :: "+String.valueOf(timeStamp)+"]");
                Log.i("","\n"+"[error [에러] :: "+String.valueOf("NULL")+"]");
                Log.e("//===========//","================================================");
                Log.i("---","---");
            }
        }
        catch (Exception e){
            //e.printStackTrace();
            Log.i("---","---");
            Log.e("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> getTimeStamp_To_Date() :: 타임 스탬프 >> Date 형 변환 실시]");
            Log.i("","\n"+"[catch [에러] :: "+String.valueOf(e.getMessage())+"]");
            Log.e("//===========//","================================================");
            Log.i("---","---");
        }

        // [리턴 결과 반환 수행 실시]
        return returnDate;
    }





    // TODO [String 문자열 데이터 널 판단 실시]
    public static Boolean stringNotNull(String data){

        /**
         * // -----------------------------------------
         * [stringNotNull 메소드 설명]
         * // -----------------------------------------
         * 1. String 문자열 데이터 널 판단 실시
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.stringNotNull("twok");
         * // -----------------------------------------
         * 3. 리턴 데이터 : 문자열 데이터가 널이 아닌 경우 true / 널인 경우 false
         * // -----------------------------------------
         * */

        // [문자열 데이터 널 판단 수행 실시]
        try {
            if (data != null
                    && data.length()>0
                    && data.trim().equals("") == false
                    && data.trim().equals("null") == false
                    && data.trim().equals("undefined") == false){ // [널이 아닌 경우]

                // [리턴 결과 반환 수행 실시]
                return true;
            }
            else { // [널인 경우]

                // [리턴 결과 반환 수행 실시]
                return false;
            }
        }
        catch (Exception e){
            //e.printStackTrace();
            Log.i("---","---");
            Log.e("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> stringNotNull() :: String 문자열 데이터 널 판단 실시]");
            Log.i("","\n"+"[catch [에러] :: "+String.valueOf(e.getMessage())+"]");
            Log.e("//===========//","================================================");
            Log.i("---","---");

            // [리턴 결과 반환 수행 실시]
            return false;
        }
    }





    // TODO [String 문자열 데이터 다중 contains 포함 여부 확인 실시]
    public static Boolean stringMultiContains(String data, String [] containsArray){

        /**
         * // -----------------------------------------
         * [stringMultiContains 메소드 설명]
         * // -----------------------------------------
         * 1. String 문자열 데이터 다중 contains 포함 여부 확인 실시
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.stringMultiContains("twok,투케이,반갑습니다", new String[] {"twok", "투케이"});
         * // -----------------------------------------
         * 3. 리턴 데이터 : 특정 배열 값을 모두 포함하는 경우 true / 아닌 경우 false
         * // -----------------------------------------
         * */

        // [문자열 데이터 및 배열 데이터 널 판단 수행 실시]
        try {
            if (data != null
                    && data.length()>0
                    && data.trim().equals("") == false
                    && data.trim().equals("null") == false
                    && data.trim().equals("undefined") == false

                    && containsArray != null
                    && containsArray.length>0){ // [널이 아닌 경우]

                // [for 문을 수행하면서 데이터 포함 체크 수행 실시]
                boolean checkContains = true;

                for (int i=0; i<containsArray.length; i++){
                    if (data.contains(containsArray[i]) == true){
                    }
                    else {
                        // [하나라도 값을 포함하지 않는 경우 false 지정]
                        checkContains = false;
                    }
                }

                // [리턴 결과 반환 수행 실시]
                return checkContains;
            }
            else { // [널인 경우]

                // [리턴 결과 반환 수행 실시]
                return false;
            }
        }
        catch (Exception e){
            //e.printStackTrace();
            Log.i("---","---");
            Log.e("//===========//","================================================");
            Log.i("","\n"+"[C_Util >> stringMultiContains() :: String 문자열 데이터 다중 contains 포함 여부 확인 실시]");
            Log.i("","\n"+"[catch [에러] :: "+String.valueOf(e.getMessage())+"]");
            Log.e("//===========//","================================================");
            Log.i("---","---");

            // [리턴 결과 반환 수행 실시]
            return false;
        }
    }
    
    
    
    
    
    // TODO [String 문자열 데이터를 Json Object 형식으로 변경 가능 한지 체크 실시]
    public static Boolean stringJsonObjectEnable(String data){

        /**
         * // -----------------------------------------
         * [stringJsonObjectEnable 메소드 설명]
         * // -----------------------------------------
         * 1. String 문자열 데이터를 Json Object 형식으로 변경 가능한지 확인 실시
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.stringJsonObjectEnable(json 형식 문자열 데이터);
         * // -----------------------------------------
         * 3. 리턴 데이터 : Json 형식으로 변경 가능한 경우 true / 아닌 경우 false
         * // -----------------------------------------
         * 4. 참고 : 일반 자바 main 에서 수행 시 안드로이드 JSONObject 찾지 못함 [안드로이드 용으로 사용]
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        boolean result = false;

        // [문자열 데이터 널 판단 수행 실시]
        if (data != null
                && data.length()>0
                && data.trim().equals("") == false
                && data.trim().equals("null") == false
                && data.trim().equals("undefined") == false){ // [널이 아닌 경우]

            // [Json Object 형식으로 변경 가능한지 확인 실시]
            try {
                JSONObject checkJson = new JSONObject(String.valueOf(data));

                // [리턴 데이터 삽입 실시]
                result = true;
            }
            catch (Exception e){
                // [Json Object 변환 에러 발생]
                // e.printStackTrace();

                // [리턴 데이터 삽입 실시]
                result = false;
            }
        }
        else { // [널인 경우]

            // [리턴 데이터 삽입 실시]
            result = false;
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> stringJsonObjectEnable() :: String 문자열 데이터 Json Object 변환 결과]");
        Log.i("","\n"+"[input :: "+String.valueOf(data)+"]");
        Log.i("","\n"+"[result :: "+String.valueOf(result)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return result;
    }
    
    
    
    
    
    // TODO [배열 형식 String 문자열 데이터를 ArrayList 로 반환 실시]
    public static ArrayList arrayListStringToArrayList(String data){

        /**
         * // -----------------------------------------
         * [arrayListStringToArrayList 메소드 설명]
         * // -----------------------------------------
         * 1. 배열 형식 String 문자열 데이터를 ArrayList 로 반환 실시
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.arrayListStringToArrayList("[투케이, 29]");
         * // -----------------------------------------
         * 3. 리턴 데이터 : ArrayList 로 반환 실시
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        ArrayList result = new ArrayList<>();
        String arrayString = "";

        // [문자열 데이터 널 판단 수행 실시]
        if (data != null
                && data.length()>0
                && data.trim().equals("") == false
                && data.trim().equals("null") == false
                && data.trim().equals("undefined") == false){ // [널이 아닌 경우]

            try {
                // [인풋으로 들어온 데이터 삽입]
                arrayString = String.valueOf(data.trim());

                // [배열 형식 데이터를 파싱하기 위해 포맷 수행 실시]
                if (arrayString.startsWith("[") == true && arrayString.endsWith("]") == true){

                    // [문자열 데이터 포맷]
                    arrayString = arrayString.substring(1, arrayString.length()-1);
                    arrayString = arrayString.replaceAll(", ", ",");

                    // [split 사용해서 문자열 파싱]
                    String [] parsingArray = arrayString.split(",");
                    for (int i=0; i<parsingArray.length; i++){
                        parsingArray[i] = parsingArray[i].trim();
                    }

                    // [ArrayList 에 배열 삽입 실시]
                    result = new ArrayList(Arrays.asList(parsingArray));
                }
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> arrayListStringToArrayList() :: 배열 형식 String 문자열 데이터를 ArrayList 로 반환 실시]");
        Log.i("","\n"+"[input :: "+String.valueOf(data)+"]");
        Log.i("","\n"+"[format :: "+String.valueOf(arrayString)+"]");
        Log.i("","\n"+"[result :: "+String.valueOf(result.toString())+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return result;
    }
    
    
    
    
    
    // TODO [html 형식 태그 제거 문자열 데이터 반환]
    public static String htmlTagRemoveString(String data){

        /**
         * // -----------------------------------------
         * [htmlTagRemoveString 메소드 설명]
         * // -----------------------------------------
         * 1. html 형식 태그 제거 문자열 데이터 반환
         * // -----------------------------------------
         * 2. 호출 방식 :
         *   String data = "<p>test url</p><p><a href=&quot;https://www.naver.com&quot;>https://www.naver.com</a></p><p>&amp;nbsp;</p><p>입니다</p><p>&amp;nbsp;</p>";
         *
         *   C_Util.htmlTagRemoveString(data);
         * // -----------------------------------------
         * 3. 리턴 데이터 : html 형식 태그 제거 문자열 반환
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        String result = "";

        // [문자열 데이터 널 판단 수행 실시]
        if (data != null
                && data.length()>0
                && data.trim().equals("") == false
                && data.trim().equals("null") == false
                && data.trim().equals("undefined") == false){ // [널이 아닌 경우]

            try {
                // [html 태그 1차 제거 실시]
                result = Html.fromHtml(data).toString();

                // [html 태그 2차 제거 위해 [&] 이스케이프 문자 카운트 실시]
                int checkCount = 0;
                for (int i=0; i<result.length(); i++){
                    if (result.charAt(i) == '&'){
                        checkCount ++;
                    }
                }
                if (checkCount > 0){
                    for (int k=0; k<checkCount; k++){
                        // [html 태그 엔티티 문자 제거 실시]
                        result = Html.fromHtml(result).toString();
                    }
                }

                // [html 태그 연속 공백 제거 실시]
                result = result.replaceAll("\\s+", " ");

                // [문자열 양쪽 끝 공백 제거 실시]
                result = result.trim();
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> htmlTagRemoveString() :: html 형식 태그 제거 문자열 데이터 반환 실시]");
        Log.i("","\n"+"[input :: "+String.valueOf(data)+"]");
        Log.i("","\n"+"[result :: "+String.valueOf(result.toString())+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return result;
    }
    
    
    
    
    
    // TODO [html 형식 태그 제거 문자열 데이터 반환]
    public static String htmlTagRemoveString_2(String data){

        /**
         * // -----------------------------------------
         * [htmlTagRemoveString_2 메소드 설명]
         * // -----------------------------------------
         * 1. html 형식 태그 제거 문자열 데이터 반환
         * // -----------------------------------------
         * 2. 호출 방식 :
         *   String data = "<p>test url</p><p><a href=&quot;https://www.naver.com&quot;>https://www.naver.com</a></p><p>&amp;nbsp;</p><p>입니다</p><p>&amp;nbsp;</p>";
         *
         *   C_Util.htmlTagRemoveString_2(data);
         * // -----------------------------------------
         * 3. 리턴 데이터 : html 형식 태그 제거 문자열 반환
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        String result = "";

        // [문자열 데이터 널 판단 수행 실시]
        if (data != null
                && data.length()>0
                && data.trim().equals("") == false
                && data.trim().equals("null") == false
                && data.trim().equals("undefined") == false){ // [널이 아닌 경우]

            try {
                // [html 태그를 제거 하기 위한 패턴 정의 실시]
                String tag_pattern = "<(/)?([a-zA-Z]*)(\\s[a-zA-Z]*=[^>]*)?(\\s)*(/)?>"; // [<p> 등 태그 제거]
                Pattern num_reg_entity_pattern = Pattern.compile("&#[0-9]+;"); // [&#09; 형태 제거]
                Pattern char_reg_entity_pattern = Pattern.compile("&[a-zA-Z]+;"); // [&amp; 형태 제거]
                Pattern char_normal_entity_pattern = Pattern.compile(" [a-zA-Z]+;"); // [amp; 형태 제거]


                // [html 태그 1차 제거 실시]
                result = data.replaceAll(tag_pattern, " ");


                // [html 태그 2차 제거 실시]
                Matcher num_reg_mat = num_reg_entity_pattern.matcher(result);
                result = num_reg_mat.replaceAll("");

                Matcher char_reg_mat = char_reg_entity_pattern.matcher(result);
                result = char_reg_mat.replaceAll("");

                Matcher char_normal_mat = char_normal_entity_pattern.matcher(result);
                result = char_normal_mat.replaceAll("");


                // [html 태그 연속 공백 제거 실시]
                result = result.replaceAll("\\s+", " ");

                // [문자열 양쪽 끝 공백 제거 실시]
                result = result.trim();
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> htmlTagRemoveString_2() :: html 형식 태그 제거 문자열 데이터 반환 실시]");
        Log.i("","\n"+"[input :: "+String.valueOf(data)+"]");
        Log.i("","\n"+"[result :: "+String.valueOf(result.toString())+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return result;
    }
    
    
    
    
    
    // TODO [string 문자열 데이터를 byte 배열 값으로 반환]
    public static byte[] stringToByte(String data){

        /**
         * // -----------------------------------------
         * [stringToByte 메소드 설명]
         * // -----------------------------------------
         * 1. string 문자열 데이터를 byte 배열 값으로 반환 수행
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.stringToByte("hello");
         * // -----------------------------------------
         * 3. 리턴 데이터 : byte array 바이트 배열 데이터
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        byte result[] = null;

        // [문자열 데이터 널 판단 수행 실시]
        if (data != null
                && data.length()>0
                && data.trim().equals("") == false
                && data.trim().equals("null") == false
                && data.trim().equals("undefined") == false){ // [널이 아닌 경우]

            try {
                result = data.getBytes("UTF-8");
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> stringToByte() :: string 문자열 데이터를 byte 배열 값으로 반환 실시]");
        Log.i("","\n"+"[input :: "+String.valueOf(data)+"]");
        Log.i("","\n"+"[result :: "+String.valueOf(Arrays.toString(result))+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return result;
    }





    // TODO [byte 배열 값을 string 문자열 데이터로 반환]
    public static String byteToString(byte[] data){

        /**
         * // -----------------------------------------
         * [byteToString 메소드 설명]
         * // -----------------------------------------
         * 1. byte 배열 값을 string 문자열 데이터로 반환
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.byteToString(new byte[] {104, 101, 108, 108, 111});
         * // -----------------------------------------
         * 3. 리턴 데이터 : string 문자열 데이터
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        String result = "";

        // [데이터 널 판단 수행 실시]
        if (data != null
                && data.length>0){ // [널이 아닌 경우]

            try {
                result = new String(data, "UTF-8");
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> byteToString() :: byte 배열 값을 string 문자열 데이터로 반환 실시]");
        Log.i("","\n"+"[input :: "+String.valueOf(Arrays.toString(data))+"]");
        Log.i("","\n"+"[result :: "+String.valueOf(result)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return result;
    }
    
    
    
    
    
    // TODO [string 문자열 데이터에서 특정 문자 개수 카운트 반환]
    public static int stringCount(String stringData, String charData){

        /**
         * // -----------------------------------------
         * [stringCount 메소드 설명]
         * // -----------------------------------------
         * 1. string 문자열 데이터에서 특정 문자 개수 카운트 반환
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.stringCount("hello,TWOK,투케이", ",");
         * // -----------------------------------------
         * 3. 리턴 데이터 : 특정 문자 개수 카운트 반환 실시
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        int result = 0;

        // [인풋 데이터 널 판단 수행 실시]
        if (stringData != null
                && stringData.length()>0
                && stringData.trim().equals("") == false
                && stringData.trim().equals("null") == false
                && stringData.trim().equals("undefined") == false

                && charData != null
                && charData.length() == 1
                && charData.trim().equals("") == false
                && charData.trim().equals("null") == false
                && charData.trim().equals("undefined") == false ){ // [널이 아닌 경우]

            try {
                // [인풋으로 들어온 문자열 데이터 배열에 삽입 실시]
                String array[] = stringData.split("");

                // [for 문을 돌면서 특정 문자 포함 확인]
                for (int i=0; i<array.length; i++){
                    if (String.valueOf(array[i]).equals(charData)){
                        result = result + 1;
                    }
                }
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> stringCount() :: string 문자열 데이터에서 특정 문자 개수 카운트 반환 실시]");
        Log.i("","\n"+"[input [string] :: "+String.valueOf(stringData)+"]");
        Log.i("","\n"+"[input [char] :: "+String.valueOf(charData)+"]");
        Log.i("","\n"+"[result [count] :: "+String.valueOf(result)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return result;
    }
    
    
    
    
    
    // TODO [ArrayList 배열 중복 데이터 제거 실시]
    public static ArrayList removeArrayOverlap(ArrayList list){

        /**
         * // -----------------------------------------
         * [removeArrayOverlap 메소드 설명]
         * // -----------------------------------------
         * 1. 배열 중복 데이터 제거 메소드
         * // -----------------------------------------
         * 2. 호출 방식 :
         *    ArrayList list = new ArrayList();
         *    list.add("하나");
         *    list.add("둘");
         *    list.add("하나");
         *
         *    C_Util.removeArrayOverlap(list);
         * // -----------------------------------------
         * 3. 리턴 데이터 : 중복 제거된 배열 데이터 반환 실시
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        ArrayList returnArray = new ArrayList();

        // [인풋 데이터 널 판단 수행 실시]
        if (list != null
                && list.size()>0
                && list.isEmpty() == false){ // [널이 아닌 경우]

            try {
                // [HashSet 을 사용해 ArrayList 배열 데이터 중복 제거 실시]
                HashSet hashSet = new HashSet<>(list);

                // [HashSet to ArrayList 변환 실시]
                returnArray = new ArrayList(hashSet);
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> removeArrayOverlap() :: ArrayList 배열 중복 데이터 제거 실시]");
        Log.i("","\n"+"[input :: "+String.valueOf(list.toString())+"]");
        Log.i("","\n"+"[result :: "+String.valueOf(returnArray.toString())+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return returnArray;
    }
    
    
    
    
    
    // TODO [String 문자열 데이터가 모두 정수 값으로 구성되어 있는지 확인 실시]
    public static Boolean stringIsNumber(String data){

        /**
         * // -----------------------------------------
         * [stringIsNumber 메소드 설명]
         * // -----------------------------------------
         * 1. String 문자열 데이터가 모두 정수 값으로 구성되어 있는지 확인 실시
         * // -----------------------------------------
         * 2. 호출 방식 :
         *   C_Util.stringIsNumber("12345");
         *   C_Util.stringIsNumber("-12345");
         *   C_Util.stringIsNumber("123hello");
         * // -----------------------------------------
         * 3. 리턴 데이터 : string 문자열 데이터가 모두 정수값으로 된 경우 true / 아니면 false
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        boolean result = true;

        // [문자열 데이터 널 판단 수행 실시]
        if (data != null
                && data.length()>0
                && data.trim().equals("") == false
                && data.trim().equals("null") == false
                && data.trim().equals("undefined") == false){ // [널이 아닌 경우]

            // [Character.isDigit 사용해 정수값 체크 실시]
            try {
                for (int i=0; i<data.length(); i++){
                    if (Character.isDigit(data.charAt(i)) == true){ // [숫자]
                    }
                    else { // [문자]
                        if (i == 0 && data.charAt(i) == '-' || data.charAt(i) == '+') { // [처음 문자가 - , + 인 경우는 통과 실시]
                        }
                        else {
                            // [리턴 데이터 삽입 실시]
                            result = false;
                        }
                    }
                }
            }
            catch (Exception e){
                // [Json Object 변환 에러 발생]
                // e.printStackTrace();

                // [리턴 데이터 삽입 실시]
                result = false;
            }
        }
        else { // [널인 경우]

            // [리턴 데이터 삽입 실시]
            result = false;
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> stringIsNumber() :: string 문자열 데이터 모두 정수 값 구성 여부 확인 실시]");
        Log.i("","\n"+"[input :: "+String.valueOf(data)+"]");
        Log.i("","\n"+"[result :: "+String.valueOf(result)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return result;
    }
    
    
    
    
    
    // TODO [Double 소수점 데이터를 특정 소수점 자릿수 기준으로 자르기 실시]
    public static String doubleCutLength(double doubleData, int length){

        /**
         * // -----------------------------------------
         * [doubleCutLength 메소드 설명]
         * // -----------------------------------------
         * 1. Double 소수점 데이터를 특정 소수점 자릿수 기준으로 자르기 실시 [반올림 없음]
         * // -----------------------------------------
         * 2. 호출 방식 :
         *   C_Util.doubleCutLength(123.4567, 2);
         *   C_Util.doubleCutLength(-123.4567, 2);
         * // -----------------------------------------
         * 3. 리턴 데이터 : 123.45 : 소수점 특정 자릿수 기준 제한 문자열 데이터
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        String result = "";

        // [인풋 데이터 체크 수행 실시]
        if (length >= 0){ // [0 자릿수 이상 들어온 경우]

            try {
                // [필요 변수 선언 실시]
                int dotCount = 0; // 점 개수
                int dotLocation = 0; // 점 위치
                int dotLength = 0; // 소수점 이하 자릿수 기준

                // [for 문을 돌면서 데이터 확인 실시]
                String strData = String.valueOf(doubleData);
                for (int i=0; i<strData.length(); i++){
                    if (strData.charAt(i) == '.'){ // 문자열 특정 자릿수가 점 (.) 인 경우
                        dotCount = dotCount + 1; // 카운트 증가
                        dotLocation = i; // 위치 지정

                        String subString = strData.substring((dotLocation + 1), strData.length());
                        dotLength = subString.length(); // 소수점 이하 자릿수 확인
                    }
                }
                /*
                Log.i("---","---");
                Log.d("//===========//","================================================");
                Log.i("","\n"+"[C_Util >> doubleCutLength() :: Double 소수점 데이터를 특정 소수점 자릿수 기준으로 자르기 실시]");
                Log.i("","\n"+"[dotCount [소수점 개수] :: "+String.valueOf(dotCount)+"]");
                Log.i("","\n"+"[dotLocation [소수점 위치] :: "+String.valueOf(dotLocation)+"]");
                Log.i("","\n"+"[dotLength [소수점 이하 자릿수] :: "+String.valueOf(dotLength)+"]");
                Log.d("//===========//","================================================");
                Log.i("---","---");
                // */

                // [정상적으로 소수점이 포함된 경우]
                if (dotCount == 1){
                    if (length > dotLength){ // [원본 데이터 보다 인풋값이 큰 경우 >> 0 값으로 채움]
                        result = strData.substring(0, strData.length());

                        int zeroCount = length - dotLength;
                        for (int j=0; j<zeroCount; j++){
                            result = result + "0";
                        }
                    }
                    else {
                        if (length == 0){
                            result = strData.substring(0, (dotLocation + length));
                        }
                        else {
                            result = strData.substring(0, (dotLocation + length + 1));
                        }
                    }
                }
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> doubleCutLength() :: Double 소수점 데이터를 특정 소수점 자릿수 기준으로 자르기 실시]");
        Log.i("","\n"+"[input [double] :: "+String.valueOf(doubleData)+"]");
        Log.i("","\n"+"[input [length] :: "+String.valueOf(length)+"]");
        Log.i("","\n"+"[result [string] :: "+String.valueOf(result)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return result;
    }
    
    
    
    
    
    // TODO [인풋으로 들어온 배열 데이터 중 부분 배열 데이터 반환 실시]
    public static ArrayList arraySubList(ArrayList list, int startIdx, int endIdx){

        /**
         * // -----------------------------------------
         * [arraySubList 메소드 설명]
         * // -----------------------------------------
         * 1. 인풋으로 들어온 배열 데이터 중 부분 배열 데이터 반환 실시
         * // -----------------------------------------
         * 2. 호출 방식 :
         *   ArrayList list = new ArrayList();
         *   list.add("하나");
         *   list.add("둘");
         *   list.add("셋");
         *   list.add("넷");
         *   list.add("다섯");
         *
         *   C_Util.arraySubList(list, 0, list.size()-1); // [배열 전체 데이터]
         *   C_Util.arraySubList(list, 1, 3); // [배열 부분 데이터 : 1, 2, 3 인덱스 데이터 출력]
         * // -----------------------------------------
         * 3. 리턴 데이터 : [하나, 둘, 셋, 넷, 다섯] / [둘, 셋, 넷]
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        ArrayList result = new ArrayList();

        // [인풋 데이터 체크 수행 실시]
        if (list != null && list.size()>0
                && startIdx >= 0 && startIdx <= endIdx
                && endIdx >= 0 && endIdx >= startIdx){

            try {
                // [subList 를 사용해 배열 자르기 수행 실시]
                result = new ArrayList(list.subList(startIdx, (endIdx+1)));
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> arraySubList() :: ArrayList 부분 배열 데이터 반환 실시]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input [list] :: "+String.valueOf(list.toString())+"]");
        Log.i("","\n"+"[input [startIdx] :: "+String.valueOf(startIdx)+"]");
        Log.i("","\n"+"[input [endIdx] :: "+String.valueOf(endIdx)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[result [length] :: "+String.valueOf(result.size())+"]");
        Log.i("","\n"+"[result [list] :: "+String.valueOf(result)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return result;
    }
    
    
    
    
    
    // TODO [ArrayList 배열 데이터 교집합 수행 실시]
    public static ArrayList arrayIntersect(ArrayList array_1, ArrayList array_2){

        /**
         * // -----------------------------------------
         * [arrayIntersect 메소드 설명]
         * // -----------------------------------------
         * 1. ArrayList 배열 데이터 교집합 수행 실시
         * // -----------------------------------------
         * 2. 호출 방식 :
         *   ArrayList list_1 = new ArrayList();
         *   list_1.add("하나");
         *   list_1.add("둘");
         *   list_1.add("셋");
         *
         *   ArrayList list_2 = new ArrayList();
         *   list_2.add("둘");
         *   list_2.add("셋");
         *   list_2.add("넷");
         *
         *   C_Util.arrayIntersect(list_1, list_2);
         * // -----------------------------------------
         * 3. 리턴 데이터 : [둘, 셋]
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        ArrayList result = new ArrayList();

        // [원본 데이터 저장]
        ArrayList original = new ArrayList();

        // [인풋 데이터 체크 수행 실시]
        if (array_1 != null && array_1.size()>0 && array_1.isEmpty() == false
                && array_2 != null && array_2.size()>0 && array_2.isEmpty() == false){

            try {
                // [원본 데이터 저장 실시]
                original = new ArrayList(array_1);

                // [retainAll 사용해 배열 데이터 교집합 실시]
                array_1.retainAll(array_2);
                result = new ArrayList(array_1);
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> arrayIntersect() :: ArrayList 배열 데이터 교집합 수행 실시]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input [array_1] :: "+String.valueOf(original)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input [array_2] :: "+String.valueOf(array_2)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[result :: "+String.valueOf(result)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return result;
    }
    
    
    
    
    
    // TODO [파일 확장자 검사 수행 실시]
    public static String urlFileExtensionName(String data){

        /**
         * // -----------------------------------------
         * [urlFileExtensionName 메소드 설명]
         * // -----------------------------------------
         * 1. url 형식 주소에서 파일 확장자가 포함되었는지 확인
         * // -----------------------------------------
         * 2. 호출 방식 :
         *   C_Util.urlFileExtensionName("http://img.championat.com/news/big/l/c/ujejn-runi_1439911080563855663.jpg");
         * // -----------------------------------------
         * 3. 리턴 데이터 : 파일 확장자 포함하는 주소인 경우 확장자 명 리턴 / 아니면 null 리턴
         *   jpg / null
         * // -----------------------------------------
         * 4. 참고 [1] : html a 태그 소스 코드
         *   <a href='f:http://img.championat.com/news/big/l/c/ujejn-runi_1439911080563855663.jpg' download="file"> 파일다운로드 </a>
         * // -----------------------------------------
         * 5. 참고 [2] : 필수 호출 방식
         *   a 태그 href 를 사용해 호출 할 경우 쿼리스트링 형태로 들어오면 안되고, 반드시 [주소/img.jpg] 처럼 경로 설정이 되어야함
         * // -----------------------------------------
         * */

        // [리턴 변수 선언 실시]
        String result = "";
        String debug = "";

        // [문자열 데이터 널 판단 수행 실시]
        try {
            if (data != null
                    && data.length()>0
                    && data.trim().equals("") == false
                    && data.trim().equals("null") == false
                    && data.trim().equals("undefined") == false
                    && data.trim().startsWith("http") == true){ // [널이 아닌 경우]

                // [파일 확장자 검사 수행 실시]
                MimeTypeMap mimeTypeMap = MimeTypeMap.getSingleton();
                String extension = String.valueOf(mimeTypeMap.getFileExtensionFromUrl(data.trim())); // [jpg]
                String mimeType = String.valueOf(mimeTypeMap.getMimeTypeFromExtension(extension)); // [image/jpeg]

                // [리턴 변수에 삽입 실시]
                result = extension;


                // [파일 확장자명 종료 확인]
                if (result != null && result.length()>0
                        && result.trim().equals("") == false && result.trim().equals("null") == false){ // [널 값이 아님 : 정상 확장자 포함]

                    // [디버그 삽입]
                    debug = "1";
                }
                else { // [널 인 경우]
                    String fileName = data.substring(data.trim().lastIndexOf('/') + 1);
                    String fileExt = String.valueOf(mimeTypeMap.getFileExtensionFromUrl(fileName.trim())); // [jpg]

                    // [리턴 변수에 삽입 실시]
                    result = fileExt;
                }


                // [쿼리 스트링에서 파일 확장자 검사 확인]
                if (result != null && result.length()>0
                        && result.trim().equals("") == false && result.trim().equals("null") == false){ // [널 값이 아님 : 정상 확장자 포함]

                    // [디버그 삽입]
                    debug = "2";
                }
                else { // [널 인 경우]
                    Uri uri = Uri.parse(data.trim());
                    String host = String.valueOf(uri.getHost()); // [호스트]
                    String endCheck = host + "?"; // [마지막 종료 형식 확인 위함 : 스키마 데이터 널 체크]

                    if (uri.getQueryParameterNames() != null
                            && uri.getQueryParameterNames().size() > 0
                            && data.trim().endsWith(endCheck.trim()) == false) { // KEY 값이 하나라도 포함된 경우

                        // [배열 순회하면서 파일 확장자 여부 값 확인 실시]
                        ArrayList keyList = new ArrayList(uri.getQueryParameterNames());
                        for (int i = 0; i < keyList.size(); i++) {

                            // [파일 이름 확인]
                            String fileExt = String.valueOf(mimeTypeMap.getFileExtensionFromUrl(uri.getQueryParameter(String.valueOf(keyList.get(i))))); // [jpg]

                            // [리턴 변수에 삽입 실시]
                            result = fileExt;
                        }

                        // [디버그 삽입]
                        debug = "3";
                    }
                }
            }
        }
        catch (Exception e){
            e.printStackTrace();
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> urlFileExtensionName() :: URL 주소 파일 확장자 포함 확인 실시]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input :: "+String.valueOf(data)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[debug :: "+String.valueOf(debug)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[result :: "+String.valueOf(result)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 결과 반환 실시]
        return result;
    }





    // TODO [다운로드 매니저 사용해 파일 다운로드 수행 실시]
    public static void appDownloadFile(Context mContext, String fileUrl){

        /**
         * // -----------------------------------------
         * [appDownloadFile 메소드 설명]
         * // -----------------------------------------
         * 1. 파일 다운로드 수행 실시 메소드 (내장 메모리 >> 공유 Download 폴더)
         * // -----------------------------------------
         * 2. 호출 방식 :
         *   - C_Util.appDownloadFile(A_Main.this, "http://img.championat.com/news/big/l/c/ujejn-runi_1439911080563855663.jpg");
         * // -----------------------------------------
         * 3. 사전 설정 사항 :
         *   - AndroidManifest >> WRITE_EXTERNAL_STORAGE , READ_EXTERNAL_STORAGE 권한 부여
         *   - AndroidManifest >> application : android:requestLegacyExternalStorage="true" 옵션 설정
         * // -----------------------------------------
         * 4. 로직 :
         *   - 인풋으로 들어온 파일 주소 널 체크 수행 실시
         *   - AndroidManifest : WRITE_EXTERNAL_STORAGE , READ_EXTERNAL_STORAGE 권한 부여 체크
         *   - 현재 날짜 및 시간 확인 실시
         *   - DownloadManager 사용해 파일 다운로드 수행 실시
         *   - 파일 저장 명칭은 현재 날짜 및 시간.확장자
         * // -----------------------------------------
         * 5. 참고 [1] : [다운로드 폴더 경로 확인]
         *   File pathFoler = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
         *   String path = pathFoler.getPath();
         * // -----------------------------------------
         * 6. 참고 [2] : html a 태그 소스 코드
         *   <a href='f:http://img.championat.com/news/big/l/c/ujejn-runi_1439911080563855663.jpg' download="file"> 파일다운로드 </a>
         * // -----------------------------------------
         * */

        try {
            if (fileUrl != null
                    && fileUrl.length()>0
                    && fileUrl.trim().equals("") == false
                    && fileUrl.trim().equals("null") == false
                    && fileUrl.trim().equals("undefined") == false
                    && fileUrl.trim().startsWith("http") == true){ // [파일 확장자 명이 널이 아닌 경우]

                // [권한 부여 상태 체크 수행 실시]
                if (ContextCompat.checkSelfPermission(mContext, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {

                    // [주소에 포함된 파일 확장자명 추출 실시]
                    MimeTypeMap mimeTypeMap = MimeTypeMap.getSingleton();
                    String extension = String.valueOf(mimeTypeMap.getFileExtensionFromUrl(fileUrl.trim())); // [jpg]
                    String mimeType = String.valueOf(mimeTypeMap.getMimeTypeFromExtension(extension)); // [image/jpeg]


                    // [파일 확장자명 종료 확인]
                    if (extension != null && extension.length()>0
                            && extension.trim().equals("") == false && extension.trim().equals("null") == false){ // [널 값이 아님 : 정상 확장자 포함]
                    }
                    else { // [널 인 경우]
                        String fileName = fileUrl.substring(fileUrl.trim().lastIndexOf('/') + 1);
                        String fileExt = String.valueOf(mimeTypeMap.getFileExtensionFromUrl(fileName.trim())); // [jpg]

                        // [리턴 변수에 삽입 실시]
                        extension = fileExt;
                    }


                    // [쿼리 스트링에서 파일 확장자 검사 확인]
                    if (extension != null && extension.length()>0
                            && extension.trim().equals("") == false && extension.trim().equals("null") == false){ // [널 값이 아님 : 정상 확장자 포함]
                    }
                    else { // [널 인 경우]
                        Uri uri = Uri.parse(fileUrl.trim());
                        String host = String.valueOf(uri.getHost()); // [호스트]
                        String endCheck = host + "?"; // [마지막 종료 형식 확인 위함 : 스키마 데이터 널 체크]

                        if (uri.getQueryParameterNames() != null
                                && uri.getQueryParameterNames().size() > 0
                                && fileUrl.trim().endsWith(endCheck.trim()) == false) { // KEY 값이 하나라도 포함된 경우

                            // [배열 순회하면서 파일 확장자 여부 값 확인 실시]
                            ArrayList keyList = new ArrayList(uri.getQueryParameterNames());
                            for (int i = 0; i < keyList.size(); i++) {

                                // [파일 이름 확인]
                                String fileExt = String.valueOf(mimeTypeMap.getFileExtensionFromUrl(uri.getQueryParameter(String.valueOf(keyList.get(i))))); // [jpg]

                                // [리턴 변수에 삽입 실시]
                                extension = fileExt;
                            }
                        }
                    }

                    // [현재 날짜 및 시간 확인 실시]
                    long time = System.currentTimeMillis();
                    SimpleDateFormat dayTime = new SimpleDateFormat("yyyyMMddkkmmss");
                    String str = dayTime.format(new Date(time));


                    // [현재 날짜 및 시간 데이터 + 확장자명 결합 실시]
                    String fileName = str.trim() + "." + extension.trim();


                    // [파일 확장자 명 널 체크 수행 후 다운로드 실시]
                    if (extension != null && extension.length()>0
                            && extension.trim().equals("") == false && extension.trim().equals("null") == false){ // [널 값이 아님 : 정상 확장자 포함]

                        // [DownloadManager 사용해 파일 다운로드 수행 실시]
                        DownloadManager manager = (DownloadManager) mContext.getSystemService(Activity.DOWNLOAD_SERVICE);
                        Uri uri = Uri.parse(fileUrl.trim()); // [파일 다운로드 주소 : 확장자명 포함되어야함]
                        DownloadManager.Request request = new DownloadManager.Request(uri); // [다운로드 매니저 객체 생성]
                        request.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED); // [앱 상단에 다운로드 표시]
                        request.setTitle(fileName); // [다운로드 제목 표시]
                        request.setDescription("Download ... "); // [다운로드 중 표시되는 내용]
                        request.setNotificationVisibility(1); // [앱 상단에 다운로드 상태 표시]
                        request.setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, fileName); // [다운로드 폴더 지정]
                        manager.enqueue(request); // [다운로드 수행]


                        // [로그 출력 실시]
                        Log.i("---","---");
                        Log.w("//===========//","================================================");
                        Log.i("","\n"+"[C_Util >> appDownloadFile() :: 파일 다운로드 수행 실시]");
                        Log.i("","\n"+"--------------------------------");
                        Log.i("","\n"+"[fileUrl :: "+String.valueOf(fileUrl)+"]");
                        Log.i("","\n"+"--------------------------------");
                        Log.i("","\n"+"[fileName :: "+String.valueOf(fileName)+"]");
                        Log.i("","\n"+"--------------------------------");
                        Log.i("","\n"+"[downloadPath :: "+String.valueOf("DIRECTORY_DOWNLOADS")+"]");
                        Log.w("//===========//","================================================");
                        Log.i("---","---");


                        // [토스트 알림 실시]
                        Toast.makeText(mContext, "파일 다운로드를 수행합니다.", Toast.LENGTH_SHORT).show();
                    }
                    else { // [널 인 경우 >> 실패 토스트]

                        // [로그 출력 실시]
                        Log.i("---","---");
                        Log.e("//===========//","================================================");
                        Log.i("","\n"+"[C_Util >> appDownloadFile() :: 파일 다운로드 수행 에러]");
                        Log.i("","\n"+"--------------------------------");
                        Log.i("","\n"+"[error :: "+String.valueOf("file extension is null")+"]");
                        Log.e("//===========//","================================================");
                        Log.i("---","---");


                        // [토스트 알림 실시]
                        Toast.makeText(mContext, "파일 확장자 명을 다시 확인해주세요.", Toast.LENGTH_SHORT).show();
                    }
                }
                else {
                    Log.i("---","---");
                    Log.e("//===========//","================================================");
                    Log.i("","\n"+"[C_Util >> appDownloadFile() :: 파일 다운로드 수행 실시]");
                    Log.i("","\n"+"--------------------------------");
                    Log.i("","\n"+"[error :: "+"PERMISSION WRITE_EXTERNAL_STORAGE NOT GRANTED"+"]");
                    Log.i("","\n"+"--------------------------------");
                    Log.i("","\n"+"[WRITE_EXTERNAL_STORAGE :: "+String.valueOf(ContextCompat.checkSelfPermission(mContext, Manifest.permission.WRITE_EXTERNAL_STORAGE))+"]");
                    Log.e("//===========//","================================================");
                    Log.i("---","---");

                    // [토스트 알림 실시]
                    Toast.makeText(mContext, "외부 저장소 접근 권한을 허용해주세요.", Toast.LENGTH_SHORT).show();
                }
            }
            else { // [파일 확장자 명이 널 인 경우]
                Log.i("---","---");
                Log.e("//===========//","================================================");
                Log.i("","\n"+"[C_Util >> appDownloadFile() :: 파일 다운로드 수행 실시]");
                Log.i("","\n"+"--------------------------------");
                Log.i("","\n"+"[error :: "+"file url is null"+"]");
                Log.i("","\n"+"--------------------------------");
                Log.i("","\n"+"[fileUrl :: "+String.valueOf(fileUrl)+"]");
                Log.e("//===========//","================================================");
                Log.i("---","---");
            }
        }
        catch (Exception e){
            e.printStackTrace();
        }

    }
    
    
    
    
    
    // TODO [LPAD 왼쪽 기준 데이터 채우기 수행 실시]
    public static String LPAD(String stringData, int lengthData, String charData){

        /**
         * // -----------------------------------------
         * [LPAD 메소드 설명]
         * // -----------------------------------------
         * 1. 왼쪽 기준 데이터 채우기 수행 실시
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.LPAD("투케이", 10, "@");
         * // -----------------------------------------
         * 3. 리턴 데이터 : @@@@@@@투케이
         * // -----------------------------------------
         * */

        // [리턴 반환 변수 선언 실시]
        String returnData = "";

        // [인풋 데이터 조건 체크 수행 실시 : 원본 문자열 길이 보다 인풋 값 길이가 더크고, char 문자가 1글자 인 경우]
        try {
            if (stringData != null
                    && stringData.length() < lengthData
                    && charData != null
                    && charData.length() == 1){ // [조건 만족 함]

                // [반복문을 수행 횟수]
                int countValue = lengthData - stringData.length();

                // [반복문 수행 실시]
                for (int i=0; i<countValue; i++){

                    // [문자 추가]
                    returnData = returnData + charData;
                }

                // [원본 추가]
                returnData = returnData + stringData;
            }
            else { // [조건 만족 안함]

                // [리턴 결과 반환 수행 실시]
                returnData = stringData;
            }
        }
        catch (Exception e){
            e.printStackTrace();
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> LPAD() :: 왼쪽 기준 데이터 채우기 수행 실시]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input [string] :: "+String.valueOf(stringData)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input [length] :: "+String.valueOf(lengthData)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input [char] :: "+String.valueOf(charData)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[return [string] :: "+String.valueOf(returnData)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[return [length] :: "+String.valueOf(returnData.length())+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 결과 반환 실시]
        return returnData;
    }





    // TODO [RPAD 오른쪽 기준 데이터 채우기 수행 실시]
    public static String RPAD(String stringData, int lengthData, String charData){

        /**
         * // -----------------------------------------
         * [RPAD 메소드 설명]
         * // -----------------------------------------
         * 1. 오른쪽 기준 데이터 채우기 수행 실시
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.RPAD("투케이", 10, "@");
         * // -----------------------------------------
         * 3. 리턴 데이터 : 투케이@@@@@@@
         * // -----------------------------------------
         * */

        // [리턴 반환 변수 선언 실시]
        String returnData = "";

        // [인풋 데이터 조건 체크 수행 실시 : 원본 문자열 길이 보다 인풋 값 길이가 더크고, char 문자가 1글자 인 경우]
        try {
            if (stringData != null
                    && stringData.length() < lengthData
                    && charData != null
                    && charData.length() == 1){ // [조건 만족 함]

                // [반복문을 수행 횟수]
                int countValue = lengthData - stringData.length();

                // [원본 추가]
                returnData = returnData + stringData;

                // [반복문 수행 실시]
                for (int i=0; i<countValue; i++){

                    // [문자 추가]
                    returnData = returnData + charData;
                }
            }
            else { // [조건 만족 안함]

                // [리턴 결과 반환 수행 실시]
                returnData = stringData;
            }
        }
        catch (Exception e){
            e.printStackTrace();
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> RPAD() :: 오른쪽 기준 데이터 채우기 수행 실시]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input [string] :: "+String.valueOf(stringData)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input [length] :: "+String.valueOf(lengthData)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input [char] :: "+String.valueOf(charData)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[return [string] :: "+String.valueOf(returnData)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[return [length] :: "+String.valueOf(returnData.length())+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 결과 반환 실시]
        return returnData;
    }
    
    
    
    
    
    // TODO [start 시작 기준 특정 문자 지우기 실시]
    public static String startRemoveChar(String stringData, String charData){

        /**
         * // -----------------------------------------
         * [startRemoveChar 메소드 설명]
         * // -----------------------------------------
         * 1. start 시작 기준 특정 문자 지우기 실시
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.startRemoveChar("@@@@@투케이@", "@");
         * // -----------------------------------------
         * 3. 리턴 데이터 : 투케이@
         * // -----------------------------------------
         * */

        // [리턴 반환 변수 선언 실시]
        String returnData = "";

        // [인풋 데이터 조건 체크 수행 실시]
        try {
            if (stringData != null
                    && stringData.length() > 0
                    && stringData.trim().equals("") == false
                    && stringData.trim().equals("null") == false
                    && stringData.trim().equals("undefined") == false

                    && charData != null
                    && charData.length() > 0
                    && charData.trim().equals("") == false
                    && charData.trim().equals("null") == false
                    && charData.trim().equals("undefined") == false){ // [조건 만족 함]

                if (stringData.contains(charData) == true){ // [전체 문자열에서 특정 문자를 포함하는지 확인 실시]

                    // [플래그 값 지정 실시]
                    boolean stopFlag = false;

                    // [for 반복문을 돌면서 데이터 삽입 실시]
                    for (int i=0; i<stringData.length(); i++) {

                        if (String.valueOf(stringData.charAt(i)).equals(charData) == true){

                            // [문자열이 제거하려는 문자와 같은 경우]
                            if (stopFlag == false){
                            }
                            else {
                                // [리턴 변수에 삽입 실시]
                                returnData = returnData + String.valueOf(stringData.charAt(i));
                            }
                        }
                        else {
                            // [문자열이 제거하려는 문자와 다른 경우]

                            // [플래그 값 변경 실시]
                            stopFlag = true;

                            // [리턴 변수에 삽입 실시]
                            returnData = returnData + String.valueOf(stringData.charAt(i));
                        }
                    }
                }
            }
        }
        catch (Exception e){
            e.printStackTrace();
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> startRemoveChar() :: start 시작 기준 특정 문자 지우기 실시]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input [string] :: "+String.valueOf(stringData)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input [char] :: "+String.valueOf(charData)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[return [string] :: "+String.valueOf(returnData)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 결과 반환 실시]
        return returnData;
    }





    // TODO [end 종료 기준 특정 문자 지우기 실시]
    public static String endRemoveChar(String stringData, String charData){

        /**
         * // -----------------------------------------
         * [endRemoveChar 메소드 설명]
         * // -----------------------------------------
         * 1. start 시작 기준 특정 문자 지우기 실시
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.endRemoveChar("@투케이@@@@@", "@");
         * // -----------------------------------------
         * 3. 리턴 데이터 : @투케이
         * // -----------------------------------------
         * */

        // [리턴 반환 변수 선언 실시]
        String returnData = "";

        // [인풋 데이터 조건 체크 수행 실시]
        try {
            if (stringData != null
                    && stringData.length() > 0
                    && stringData.trim().equals("") == false
                    && stringData.trim().equals("null") == false
                    && stringData.trim().equals("undefined") == false

                    && charData != null
                    && charData.length() > 0
                    && charData.trim().equals("") == false
                    && charData.trim().equals("null") == false
                    && charData.trim().equals("undefined") == false){ // [조건 만족 함]

                if (stringData.contains(charData) == true){ // [전체 문자열에서 특정 문자를 포함하는지 확인 실시]

                    // [플래그 값 지정 실시]
                    boolean stopFlag = false;

                    // [for 반복문을 돌면서 데이터 삽입 실시]
                    for (int i=stringData.length()-1; i>=0; i--) {

                        if (String.valueOf(stringData.charAt(i)).equals(charData) == true){

                            // [문자열이 제거하려는 문자와 같은 경우]
                            if (stopFlag == false){
                            }
                            else {
                                // [리턴 변수에 삽입 실시]
                                returnData = String.valueOf(stringData.charAt(i)) + returnData;
                            }
                        }
                        else {
                            // [문자열이 제거하려는 문자와 다른 경우]

                            // [플래그 값 변경 실시]
                            stopFlag = true;

                            // [리턴 변수에 삽입 실시]
                            returnData = String.valueOf(stringData.charAt(i)) + returnData;
                        }
                    }
                }
            }
        }
        catch (Exception e){
            e.printStackTrace();
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> endRemoveChar() :: end 종료 기준 특정 문자 지우기 실시]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input [string] :: "+String.valueOf(stringData)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input [char] :: "+String.valueOf(charData)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[return [string] :: "+String.valueOf(returnData)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 결과 반환 실시]
        return returnData;
    }
    
    
    
    
    
    // TODO [디바이스 소프트웨어 OS 버전 확인]
    public static String getDeviceOsVersion(){

        /**
         * // -----------------------------------------
         * [getDeviceOsVersion 메소드 설명]
         * // -----------------------------------------
         * 1. 디바이스 소프트웨어 OS 버전 확인
         * // -----------------------------------------
         * 2. 호출 방식 :
         *   C_Util.getDeviceOsVersion();
         * // -----------------------------------------
         * 3. 리턴 데이터 : 휴대폰 설정 디바이스 소프트웨어 OS 버전 리턴
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        String returnData = "";

        // [로직 처리 수행 실시]
        try {

            // [Build VERSION 사용해 정보 확인 실시]
            returnData = String.valueOf(Build.VERSION.RELEASE);
        }
        catch (Exception e){
            e.printStackTrace();
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> getDeviceOsVersion() :: 디바이스 소프트웨어 OS 버전 확인 실시]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[result :: "+String.valueOf(returnData)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return returnData;
    }
    
    
    
    
    
    // TODO [String 문자열 데이터가 URL 형식으로 파싱 가능 한지 체크 실시]
    public static boolean stringIsUrlParsing(String url){

        /**
         * // -----------------------------------------
         * [stringIsUrlParsing 메소드 설명]
         * // -----------------------------------------
         * 1. String 문자열 데이터가 URL 형식으로 파싱 가능 한지 체크 실시
         * // -----------------------------------------
         * 2. 호출 방식 :
         *
         *   C_Util.stringIsUrlParsing("https://www.naver.com");
         *   C_Util.stringIsUrlParsing("test.co.kr");
         * // -----------------------------------------
         * 3. 리턴 데이터 : true / false
         * // -----------------------------------------
         * */

        // [리턴 데이터 변수 선언 실시]
        boolean returnData = false;

        // [인풋 데이터 널 체크 수행 실시]
        if (url != null && url.length()>0 && url.equals("") == false
                && url.trim().equals("null") == false && url.trim().equals("undefined") == false
                && url.startsWith("http") == true){

            try {
                // [URL 형식으로 파싱 가능 한지 확인 실시]
                URL checkUrl = new URL(url);

                // [리턴 변수 삽입 실시]
                returnData = true;
            }
            catch (Exception e){
                //e.printStackTrace();
            }
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> stringIsUrlParsing() :: String 문자열 데이터가 URL 형식으로 파싱 가능 한지 체크 실시]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[input :: "+String.valueOf(url)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[result :: "+String.valueOf(returnData)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 데이터 반환 실시]
        return returnData;
    }
    
    
    
    
    
    // TODO [현재 날짜 및 시간 타임 스탬프 확인]
    public static String getTimeStamp(){

        /**
         * // -----------------------------------------
         * [getTimeStamp 메소드 설명]
         * // -----------------------------------------
         * 1. 현재 날짜 및 시간 데이터를 13 자리 타임 스탬프 값으로 반환
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.getTimeStamp();
         * // -----------------------------------------
         * 3. 리턴 데이터 : 1663031163703
         * // -----------------------------------------
         * */

        // [리턴 반환 변수 선언 실시]
        String returnData = "";
        String dateNow = "";

        // [인풋 데이터 조건 체크 수행 실시]
        try {

            // [타임 스탬프 객체 생성]
            Timestamp timestamp = new Timestamp(System.currentTimeMillis());
            returnData = String.valueOf(timestamp.getTime()); // 타임 스탬프 밀리 세컨드


            // [현재 날짜 및 시간 검증]
            Date date = new Date(Long.parseLong(returnData));

            // [타임 스탬프 값을 포맷 Date 형식으로 변경]
            SimpleDateFormat sdf = new SimpleDateFormat ("yyyyMMddkkmmss");
            dateNow = String.valueOf(sdf.format(date));
        }
        catch (Exception e){
            e.printStackTrace();
        }

        // [로그 출력 실시]
        ///*
        Log.i("---","---");
        Log.d("//===========//","================================================");
        Log.i("","\n"+"[C_Util >> getTimeStamp() :: 현재 날짜 및 시간 타임 스탬프 확인]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[date :: "+String.valueOf(dateNow)+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[return [length] :: "+String.valueOf(returnData.length())+"]");
        Log.i("","\n"+"--------------------------------");
        Log.i("","\n"+"[return [timeStamp] :: "+String.valueOf(returnData)+"]");
        Log.d("//===========//","================================================");
        Log.i("---","---");
        // */

        // [리턴 결과 반환 실시]
        return returnData;
    }
    
    
    
    
    
    // TODO [앱 캐시 초기화 수행 실시]
    public static void clearAppCache(Context mContext){

        /**
         * // -----------------------------------------
         * [clearAppCache 메소드 설명]
         * // -----------------------------------------
         * 1. 애플리케이션 앱 캐시 삭제 수행 메소드
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.clearAppCache(A_Main.this);
         * // -----------------------------------------
         * 3. 확인 방법 : 애플리케이션 설정 >> 캐시 용량 확인
         * // -----------------------------------------
         * */

        try {
            File cache = mContext.getCacheDir();
            if(cache != null && cache.exists() == true){
                Log.i("---","---");
                Log.w("//===========//","================================================");
                Log.i("","\n"+"[C_Util >> clearAppCache() :: 앱 캐시 폴더 존재 확인 및 삭제 수행]");
                Log.i("","\n"+"[url :: "+String.valueOf(cache.toURI())+"]");
                Log.i("","\n"+"[getName :: "+String.valueOf(cache.getName())+"]");
                Log.i("","\n"+"[cacheList :: "+String.valueOf(Arrays.toString(cache.list()))+"]");
                Log.w("//===========//","================================================");
                Log.i("---","---");

                try {
                    // [앱 캐시 삭제 수행 실시]
                    cache.delete();

                    deleteCache(cache);
                }
                catch (Exception ex){
                    ex.printStackTrace();
                }

            }
            else {
                Log.i("---","---");
                Log.e("//===========//","================================================");
                Log.i("","\n"+"[C_Util >> clearAppCache() :: 앱 캐시 폴더 존재 하지 않음]");
                Log.e("//===========//","================================================");
                Log.i("---","---");
            }
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }





    // TODO [앱 캐시 및 데이터 초기화 수행 실시]
    public static void clearAppData(Context mContext){

        /**
         * // -----------------------------------------
         * [clearAppData 메소드 설명]
         * // -----------------------------------------
         * 1. 애플리케이션 앱 캐시 및 데이터 삭제 수행 메소드
         * // -----------------------------------------
         * 2. 호출 방식 : C_Util.clearAppData(A_Main.this);
         * // -----------------------------------------
         * 3. 확인 방법 : 애플리케이션 설정 >> 데이터, 캐시 용량 확인
         * // -----------------------------------------
         * */

        try {
            File cache = mContext.getCacheDir();
            File appDir = new File(cache.getParent());
            if(appDir != null && appDir.exists() == true){
                Log.i("---","---");
                Log.w("//===========//","================================================");
                Log.i("","\n"+"[C_Util >> clearAppData() :: 앱 캐시 및 데이터 폴더 존재 확인 및 삭제 수행]");
                Log.i("","\n"+"[url :: "+String.valueOf(appDir.toURI())+"]");
                Log.i("","\n"+"[getName :: "+String.valueOf(appDir.getName())+"]");
                Log.i("","\n"+"[cacheList :: "+String.valueOf(Arrays.toString(appDir.list()))+"]");
                Log.w("//===========//","================================================");
                Log.i("---","---");

                try {
                    // [앱 캐시 및 데이터 삭제 수행 실시]
                    appDir.delete();

                    deleteCache(appDir);
                }
                catch (Exception ex){
                    ex.printStackTrace();
                }

            }
            else {
                Log.i("---","---");
                Log.e("//===========//","================================================");
                Log.i("","\n"+"[C_Util >> clearAppData() :: 앱 캐시 및 데이터 폴더 존재 하지 않음]");
                Log.e("//===========//","================================================");
                Log.i("---","---");
            }
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }





    // TODO [앱 캐시 초기화 로직 메소드]
    public static boolean deleteCache(File dir){
        // [파일이 Null 인지 Null 이 아니라면 폴더 인지 체크 실시]
        if(dir != null && dir.isDirectory()){

            // [Null 도 아니고 폴더도 아니라면 폴더안 파일 리스트를 호출]
            String[] children = dir.list();

            // [파일 리스트를 반복문으로 호출]
            for(String child : children){
                try {
                    // [파일 리스트중 폴더가 존재할 수 있기 때문에 재귀호출]
                    boolean isSuccess = deleteCache(new File(dir, child));
                    if(!isSuccess){
                        return false;
                    }
                }
                catch (Exception e){
                    e.printStackTrace();
                    return false;
                }
            }
        }
        return dir.delete();
    }
    
    
    
    
    
    // TODO [실제 디바이스 기기 모델 이름 명칭 확인]
	public static String getDeviceModelName() {

		/**
		 * // -----------------------------------------
		 * [getDeviceModelName 메소드 설명]
		 * // -----------------------------------------
		 * 1. 실제 디바이스 기기 모델 이름 명칭 확인
		 * // -----------------------------------------
		 * 2. 호출 방법 : C_Util.getDeviceModelName();
		 * // -----------------------------------------
		 * 3. 리턴 데이터 :
		 *
		 * [samsung] SM-A500S
		 * [google] sdk_gphone_arm64
		 * // -----------------------------------------
		 * */


		// [리턴 데이터 선언 실시]
		String returnData = "";


		// [로직 처리 실시]
		try {

			String brand = "["+String.valueOf(Build.BRAND)+"]";
			String model = String.valueOf(Build.MODEL);

			// [리턴 변수에 결합]
			returnData = brand.replaceAll(" ", "") + " " + model.replaceAll(" ", "");
		} catch (Exception e) {
			e.printStackTrace();

			// [리턴 변수에 결합]
			returnData = "[Error] Exception";
		}


		// [로그 출력 실시]
		Log.i("---","---");
		Log.d("//===========//","================================================");
		Log.i("","\n"+"[C_Util >> getDeviceModelName() :: 디바이스 실제 기기 모델 명칭 확인]");
		Log.i("","\n"+"-----------------------------------------");
		Log.i("","\n"+"[return :: "+String.valueOf(returnData)+"]");
		Log.d("//===========//","================================================");
		Log.i("---","---");


		// [리턴 결과 반환]
		return returnData;
	}



} // TODO [클래스 종료]

 

---