안드로이드 웹뷰 기능 제작중

package com.sihwawon.android

import android.R.attr
import android.R.attr.*
import android.annotation.SuppressLint
import android.app.AlertDialog
import android.app.Dialog
import android.content.DialogInterface
import android.content.Intent
import android.graphics.Bitmap
import android.net.Uri
import android.net.http.SslError
import android.os.Build
import android.os.Bundle
import android.os.Environment
import android.os.Message
import android.provider.MediaStore
import android.util.Log
import android.view.View
import android.view.ViewGroup
import android.webkit.*
import android.widget.ProgressBar
import androidx.appcompat.app.AppCompatActivity
import java.io.File
import java.util.*
import java.util.UUID
import android.widget.Toast
import android.view.Gravity
import android.webkit.WebView
import android.webkit.WebViewClient
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
import android.webkit.ValueCallback
import java.io.IOException
import java.text.SimpleDateFormat
import android.app.Activity
import android.content.Intent.ACTION_VIEW
import android.content.res.Configuration
import android.text.TextUtils
import android.webkit.WebChromeClient
import android.os.Parcelable
import androidx.core.content.FileProvider
import android.webkit.WebChromeClient.FileChooserParams
import androidx.annotation.RequiresApi
import android.print.PrintAttributes
import android.print.PrintManager
import android.view.KeyEvent
import kotlin.time.days


class MainActivity : AppCompatActivity() {

    private lateinit var mWebView: WebView
    private var pWebView: WebView? = null
    private lateinit var mProgressBar: ProgressBar
    private var thisUrl: String? = null
    private var barcode: String? = ""
    private var popup: Boolean? = false

    //for attach files
    private var mCameraPhotoPath: String? = null
    private var mFilePathCallback: ValueCallback<Array<Uri>>? = null
    internal var doubleBackToExitPressedOnce = false
    val INPUT_FILE_REQUEST_CODE = 1


    @SuppressLint("SetJavaScriptEnabled")
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 프로그램 시작
        var version = BuildConfig.VERSION_CODE
        // dbHelper = DBHelper(this, "local.db", null, version.toInt())
        // database = dbHelper.writableDatabase




        mWebView = findViewById(R.id.myWebView)
        pWebView = findViewById(R.id.ptWebView)
        mProgressBar = findViewById(R.id.progressBar)

        mWebView.apply {
            webViewClient = WebViewClientClass()  // new WebViewClient()); //클릭시 새창 안뜨게

            //팝업이나 파일 업로드 등 설정해주기 위해 webView.webChromeClient를 설정
            //웹뷰에서 크롬이 실행가능&& 새창띄우기는 안됨
            //webChromeClient = WebChromeClient()

            //웹뷰에서 팝업창 호출하기 위해
            webChromeClient = object : WebChromeClient() {
                @SuppressLint("SetJavaScriptEnabled")
                override fun onCreateWindow(view: WebView?, isDialog: Boolean, isUserGesture: Boolean, resultMsg: Message?): Boolean {
                    val newWebView = WebView(this@MainActivity).apply {
                        webViewClient = WebViewClientClass()
                        settings.javaScriptEnabled = true
                        settings.javaScriptCanOpenWindowsAutomatically = true
                        settings.setSupportMultipleWindows(true)
                        settings.setAllowFileAccess(true)
                    }

                    val dialog = Dialog(this@MainActivity).apply {
                        setContentView(newWebView)
                        window!!.attributes.width = ViewGroup.LayoutParams.MATCH_PARENT
                        window!!.attributes.height = ViewGroup.LayoutParams.MATCH_PARENT
                        show()
                    }

                    newWebView.webChromeClient = object : WebChromeClient() {
                        // 경고창 제어
                        override fun onJsAlert(view: WebView, url: String, message: String, result: JsResult): Boolean {
                            AlertDialog.Builder(view.context)
                                .setTitle("안내")
                                .setMessage(message)
                                .setPositiveButton(
                                    android.R.string.ok
                                ) { dialog, which -> result.confirm() }
                                .setCancelable(false)
                                .create()
                                .show()
                            return true
                        }

                        // 확인창 제어
                        override fun onJsConfirm(view: WebView?, url: String?, message: String?, result: JsResult?): Boolean {
                            AlertDialog.Builder(view!!.context)
                                .setTitle("확인")
                                .setMessage(message)
                                .setPositiveButton(
                                    "Yes"
                                ) { dialog, which -> result!!.confirm() }
                                .setNegativeButton(
                                    "No"
                                ) { dialog, which -> result!!.cancel() }
                                .setCancelable(false)
                                .create()
                                .show()
                            return true
                        }

                        // 입력창 제어
                        override fun onJsPrompt(view: WebView?, url: String?, message: String?, defaultValue: String?, result: JsPromptResult?): Boolean {
                            return super.onJsPrompt(view, url, message, defaultValue, result)
                        }
                        //
                        override fun onShowFileChooser(
                            webView: WebView?,
                            filePathCallback: ValueCallback<Array<Uri>>?,
                            fileChooserParams: FileChooserParams?
                        ): Boolean {
                            if (mFilePathCallback != null) {
                                mFilePathCallback!!.onReceiveValue(null)
                            }
                            mFilePathCallback = filePathCallback

                            var takePictureIntent: Intent? = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
                            if (takePictureIntent!!.resolveActivity(this@MainActivity.packageManager) != null) {
                                // Create the File where the photo should go
                                var photoFile: File? = null
                                try {
                                    photoFile = createImageFile()
                                    takePictureIntent.putExtra("PhotoPath", mCameraPhotoPath)
                                } catch (ex: IOException) {
                                    // Error occurred while creating the File
                                    Log.e("debug::", "Unable to create Image File", ex)
                                }

                                // Continue only if the File was successfully created
                                if (photoFile != null) {
                                    mCameraPhotoPath = "file:" + photoFile.absolutePath
                                    takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT,
                                        Uri.fromFile(photoFile))
                                } else {
                                    takePictureIntent = null
                                }
                            }

                            val contentSelectionIntent = Intent(Intent.ACTION_GET_CONTENT)
                            contentSelectionIntent.addCategory(Intent.CATEGORY_OPENABLE)
                            contentSelectionIntent.type = "image/*"

                            // 파일 업로드 선택할 수 있게 처리함.
                            val intentArray: Array<Intent?>
                            if (takePictureIntent != null) {
                                intentArray = arrayOf(takePictureIntent)
                            } else {
                                intentArray = arrayOfNulls(0)
                            }

                            val chooserIntent = Intent(Intent.ACTION_CHOOSER)
                            chooserIntent.putExtra(Intent.EXTRA_INTENT, contentSelectionIntent)
                            chooserIntent.putExtra(Intent.EXTRA_TITLE, "선택")
                            chooserIntent.putExtra(Intent.EXTRA_INITIAL_INTENTS, intentArray)
                            startActivityForResult(chooserIntent, INPUT_FILE_REQUEST_CODE)

                            return true
                        }

                        //
                        override fun onCloseWindow(window: WebView?) {
                            dialog.dismiss()
                            newWebView.destroy()
                            window?.destroy()
                        }
                    }

                    //
                    dialog?.setOnDismissListener {
                        newWebView.destroy()
                    }

                    // 자바스크립트 호출 Bridge 함수
                    newWebView.addJavascriptInterface(CustomJavaScriptCallback(), "appCall");

                    //
                    (resultMsg?.obj as WebView.WebViewTransport).webView = newWebView
                    resultMsg.sendToTarget()
                    return true
                }
            }

            // 웹뷰 설정
            settings.javaScriptEnabled = true
            settings.setSupportMultipleWindows(true) // 새창띄우기 허용여부
            settings.javaScriptCanOpenWindowsAutomatically = true // 자바스크립트 새창뛰우기 (멀티
            settings.loadWithOverviewMode = true //메타태크 허용여부
            settings.useWideViewPort = true //화면 사이즈 맞추기 허용여부
            settings.setSupportZoom(true)//화면 줌 허용여부
            settings.builtInZoomControls = false//화면 확대 축소 허용여부

            // Enable and setup web view cache
            settings.cacheMode = WebSettings.LOAD_NO_CACHE //브라우저 캐시 허용여부 // WebSettings.LOAD_DEFAULT
            settings.domStorageEnabled =  true//로컬저장소 허용여부
            settings.displayZoomControls = true

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                settings.safeBrowsingEnabled = true// api 26
            }

            if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                settings.mediaPlaybackRequiresUserGesture = false
            }

            settings.allowContentAccess = true

            // 아래 설정을 이용하니깐 앱 크래시가 나서 제거함.
            //settings.setGeolocationEnabled(true)
            //if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
            //    settings.allowUniversalAccessFromFileURLs = true
            //}

            settings.allowFileAccess = true
            //settings.loadsImagesAutomatically = true
            fitsSystemWindows = true
            settings.setAllowFileAccess(true)
            settings.allowFileAccessFromFileURLs = true
        }
        //
        mWebView.settings.userAgentString = mWebView.getSettings().getUserAgentString() + " MySystems (trudskr_app) (uuid|"+GetDevicesUUID()+")"

        // 자바스크립트 호출 Bridge 함수
        mWebView.addJavascriptInterface(CustomJavaScriptCallback(), "appCall");

        //
        val url = "https://blog.truds.kr"
        mWebView.loadUrl(url)
        mWebView.requestFocus() // 포커스 이동하기
    }

    // URL 주소로 프린터하기
    private fun doWebViewPrint(ss: String) {
        pWebView!!.webViewClient = object : WebViewClient() {
            override fun shouldOverrideUrlLoading(view: WebView, url: String): Boolean {
                return false
            }

            override fun onPageStarted(view: WebView, url: String, favicon: Bitmap?) {
                pWebView!!.visibility = View.INVISIBLE
            }

            override fun onPageFinished(view: WebView, url: String) {
                val printManager = getSystemService(PRINT_SERVICE) as PrintManager
                val jobName = "D-POP Printer 서비스"
                val printAdapter = pWebView!!.createPrintDocumentAdapter(jobName)
                printManager.print(jobName, printAdapter, PrintAttributes.Builder().build())
                super.onPageFinished(view, url)
            }

            override fun onPageCommitVisible (view: WebView, url: String) {
                pWebView!!.visibility = View.GONE
            }
        }
        //
        pWebView!!.loadUrl(ss)
        //pWebView!!.loadDataWithBaseURL(null, ss, "text/html", "UTF-8", null);
    }

    // UUID 획득
    private fun GetDevicesUUID() : String {
        val uuid = UUID.randomUUID()
        val randomUUIDString = uuid.toString().toUpperCase().trim()
        return randomUUIDString
    }

    // 사진을 찍으면은 이미지 파일을 작성해서 업로드 하기 위한 함수
    @Throws(IOException::class)
    private fun createImageFile(): File {
        // Create an image file name
        val timeStamp = SimpleDateFormat("yyyyMMddHHmmss").format(Date())
        val imageFileName = timeStamp
        val storageDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES)

        return File.createTempFile(
            imageFileName, /* prefix */
            ".jpg", /* suffix */
            storageDir      /* directory */
        )
    }

    //
    public override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        if (requestCode != INPUT_FILE_REQUEST_CODE || mFilePathCallback == null) {
            super.onActivityResult(requestCode, resultCode, data)
            return
        }

        var results: Array<Uri>? = null
        // Check that the response is a good one
        if (resultCode == Activity.RESULT_OK) {
            if (data == null) {
                // If there is not data, then we may have taken a photo
                if (mCameraPhotoPath != null) {
                    results = arrayOf(Uri.parse(mCameraPhotoPath))
                }
            } else {
                val dataString = data.dataString
                if (dataString != null) {
                    results = arrayOf(Uri.parse(dataString))
                }
            }
        }

        mFilePathCallback!!.onReceiveValue(results)
        mFilePathCallback = null

        return
    }

    //웹뷰에서 홈페이지 JS 인터페이스 연결하는 Briget
    inner class CustomJavaScriptCallback {
        @JavascriptInterface
        fun print() {
            runOnUiThread { doWebViewPrint(thisUrl.toString()) }
        }
    }

    //웹뷰에서 홈페이지를 띄웠을때 새창이 아닌 기존창에서 실행이 되도록 아래 코드를 넣어준다.
    inner class WebViewClientClass: WebViewClient() {
        override fun shouldOverrideKeyEvent(view: WebView?, event: KeyEvent?): Boolean {
//            return super.shouldOverrideKeyEvent(view, event)
            val keyCode = event!!.keyCode
            val unicodeChar = event!!.unicodeChar.toChar()

            if(event.action == KeyEvent.ACTION_DOWN) {
                //
                when (keyCode) {
                    KeyEvent.KEYCODE_BACK -> {
                        mWebView.goBack()
                        return true
                    }
                }

            }
            return false
        }

        override fun shouldOverrideUrlLoading(view: WebView, url: String): Boolean {
            if(url.startsWith("intent://")){
                startActivity(Intent(ACTION_VIEW, Uri.parse(url.replace("intent://", "http://"))))
            } else {
                view.loadUrl(url)
            }
            return true
        }

        override fun shouldOverrideUrlLoading(view: WebView?, request: WebResourceRequest?): Boolean {
            return super.shouldOverrideUrlLoading(view, request)
        }

        override fun onPageStarted(view: WebView, url: String, favicon: Bitmap?) {
            super.onPageStarted(view, url, favicon)
            mWebView.visibility = View.INVISIBLE
            mProgressBar.visibility = ProgressBar.VISIBLE
        }

        override fun onPageFinished(view: WebView?, url: String?) {
            super.onPageFinished(view, url)
            thisUrl = url.toString()
            barcode = ""    // 바코드 초기화
        }

        override fun onLoadResource(view: WebView?, url: String?) {
            super.onLoadResource(view, url)
        }

        override fun onPageCommitVisible (view: WebView, url: String) {
            super.onPageCommitVisible(view, url)
            mProgressBar.visibility = ProgressBar.GONE
            mWebView.visibility = View.VISIBLE
        }

        override fun onReceivedError(view: WebView?, request: WebResourceRequest?, error: WebResourceError?) {
            when (error?.errorCode) {
                ERROR_AUTHENTICATION -> { showToast("서버에서 사용자 인증 실패") }
                ERROR_BAD_URL -> { showToast("잘못된 URL") }
                ERROR_CONNECT -> { showToast("서버로 연결 실패") }
                ERROR_FAILED_SSL_HANDSHAKE -> { showToast("SSL handshake 수행 실패") }
                ERROR_FILE -> { showToast("일반 파일 오류") }
                ERROR_FILE_NOT_FOUND -> { showToast("파일을 찾을 수 없습니다") }
                ERROR_HOST_LOOKUP -> { showToast("서버 또는 프록시 호스트 이름 조회 실패")}
                ERROR_IO -> { showToast("서버에서 읽거나 서버로 쓰기 실패")}
                ERROR_PROXY_AUTHENTICATION -> { showToast("프록시에서 사용자 인증 실패")}
                ERROR_REDIRECT_LOOP -> { showToast("너무 많은 리디렉션")}
                ERROR_TIMEOUT -> { showToast("연결 시간 초과")}
                ERROR_TOO_MANY_REQUESTS -> { showToast("페이지 로드중 너무 많은 요청 발생")}
                //ERROR_UNKNOWN -> { showToast("일반 오류") }
                ERROR_UNSUPPORTED_AUTH_SCHEME -> { showToast("지원되지 않는 인증 체계")}
                ERROR_UNSUPPORTED_SCHEME -> { showToast("URI가 지원되지 않는 방식")}
            }
            super.onReceivedError(view, request, error)
        }

        override fun onReceivedHttpError(view: WebView?, request: WebResourceRequest?, errorResponse: WebResourceResponse?) {
            super.onReceivedHttpError(view, request, errorResponse)
        }

        override fun onReceivedSslError(view: WebView, handler: SslErrorHandler, error: SslError) {
            var builder: android.app.AlertDialog.Builder =
                android.app.AlertDialog.Builder(this@MainActivity)
            var message = "SSL Certificate error."
            when (error.primaryError) {
                SslError.SSL_UNTRUSTED -> message = "The certificate authority is not trusted."
                SslError.SSL_EXPIRED -> message = "The certificate has expired."
                SslError.SSL_IDMISMATCH -> message = "The certificate Hostname mismatch."
                SslError.SSL_NOTYETVALID -> message = "The certificate is not yet valid."
            }
            message += " Do you want to continue anyway?"
            builder.setTitle("SSL Certificate Error")
            builder.setMessage(message)
            builder.setPositiveButton("continue",
                DialogInterface.OnClickListener { _, _ -> handler.proceed() })
            builder.setNegativeButton("cancel",
                DialogInterface.OnClickListener { dialog, which -> handler.cancel() })
            val dialog: android.app.AlertDialog? = builder.create()
            dialog?.show()
        }
    }

    // Toast 로 메세지 띄우기
    fun showToast(msg : String) {
        var toast = Toast.makeText(applicationContext, msg, Toast.LENGTH_LONG)
        toast.setGravity(Gravity.CENTER, Gravity.CENTER_HORIZONTAL, Gravity.CENTER_VERTICAL)
        toast.show()
    }

    // 전체 화면 모드로 전환
    private fun doFullScreen(){
        window.decorView.systemUiVisibility = (View.SYSTEM_UI_FLAG_IMMERSIVE
                // Set the content to appear under the system bars so that the
                // content doesn't resize when the system bars hide and show.
                or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                // Hide the nav bar and status bar
                or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                or View.SYSTEM_UI_FLAG_FULLSCREEN)
    }

    // 뒤로가기 버튼 종료전에 확인창 나오도록 처리
    override fun onBackPressed() {
        if (mWebView.canGoBack()) {
            mWebView.goBack()
        } else {
            var builder = AlertDialog.Builder(this)
                .setTitle("안내")
                .setMessage("종료 하시겠습니까?")
                .setPositiveButton("Yes") { dialog, which -> super.onBackPressed() }
                .setNeutralButton("NO", null)
                .create()
            builder.show()
        }
    }
}