Android webview image upload

Question

developed a webview app, I have an option to upload image (input type = "file"). In the browser functions normally, but within the webview, it does not. I would like some help to resolve this problem.

Answer 1

because you not post any code, take a look of my code. It allow webview to upload image from camera or galery

class HandlingWebview(){
private var mFilePathCallback: ValueCallback<Array<Uri>>? = null
    private var mCameraPhotoPath: String? = null


    companion object {
        const val CHOOSE_FILE_REQUEST_CODE = 9685
    }

    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)
        initObserver()
        initView()
    }

    private val permissionUtils: PermissionUtils by lazy {
        PermissionUtils(
            this,
            trackingService,
            getString(R.string.rationale_storage),
            Constant.RC_PERMISSIONS_DOWNLOAD_DOCS,
            Constant.PERMISSIONS_DOWNLOAD_DOCS
        )
    }

    private fun initView() {

        binding.webView.settings.apply {
            javaScriptEnabled = true
            loadWithOverviewMode = true
            useWideViewPort = true
            domStorageEnabled = true
        }
        binding.webView.setOnKeyListener(object : View.OnKeyListener {
            override fun onKey(v: View?, keyCode: Int, event: KeyEvent?): Boolean {
                if (event?.action == KeyEvent.ACTION_DOWN) {
                    val webView = v as WebView
                    when (keyCode) {
                        KeyEvent.KEYCODE_BACK -> if (webView.canGoBack()) {
                            webView.goBack()
                            return true
                        }
                    }
                }
                return false
            }
        })
        binding.webView.apply {
            loadUrl(url)
        }
        binding.webView.webViewClient = object : WebViewClient() {

            override fun doUpdateVisitedHistory(view: WebView?, url: String?, isReload: Boolean) {
              
                super.doUpdateVisitedHistory(view, url, isReload)
            }
        }
        binding.webView.webChromeClient = object : WebChromeClient() {
            override fun onShowFileChooser(
                webView: WebView?,
                filePathCallback: ValueCallback<Array<Uri>>?,
                fileChooserParams: FileChooserParams?
            ): Boolean {
                if (permissionUtils.isAllPermissionAllowed()) {
                    // Double check that we don't have any existing callbacks
                    startActivityChooser(fileChooserParams, filePathCallback)
                } else observePermissionResult(permissionUtils.build().asLiveData(), fileChooserParams, filePathCallback)

                return true
            }
        }
    }

    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) = permissionUtils.onRequestPermissionsResult(requestCode, permissions, grantResults)

    private fun startActivityChooser(
        fileChooserParams: WebChromeClient.FileChooserParams?,
        filePathCallback: ValueCallback<Array<Uri>>?
    ) {
        mFilePathCallback?.onReceiveValue(null)
        mFilePathCallback = filePathCallback
        activity?.packageManager?.let {
            var takePictureIntent: Intent? =  Intent(MediaStore.ACTION_IMAGE_CAPTURE)
            if (takePictureIntent?.resolveActivity(it) != null){
                var photoFile: File? = null
                try {
                    photoFile = createImageFile()
                    takePictureIntent.putExtra("PhotoPath", mCameraPhotoPath)
                } catch (ex: IOException) {
                    // Error occurred while creating the File
                    Timber.i("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?> = takePictureIntent?.let { arrayOf(it) } ?: arrayOfNulls(0)
            val chooserIntent = Intent(Intent.ACTION_CHOOSER)
            chooserIntent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
            chooserIntent.putExtra(Intent.EXTRA_INTENT, contentSelectionIntent)
            chooserIntent.putExtra(Intent.EXTRA_TITLE, "Image Chooser")
            chooserIntent.putExtra(Intent.EXTRA_INITIAL_INTENTS, intentArray)
            startActivityForResult(chooserIntent, CHOOSE_FILE_REQUEST_CODE)
        }
    }

    private fun initObserver() {}

    private fun observePermissionResult(
        permissionResult: LiveData<Event<PermissionUtils.Companion.PermissionResult>>,
        fileChooserParams: WebChromeClient.FileChooserParams?,
        filePathCallback: ValueCallback<Array<Uri>>?
    ) {
        permissionResult.observe(viewLifecycleOwner) { event ->
            event?.getContentIfNotHandled()?.let {
                when (it) {
                    is PermissionUtils.Companion.PermissionResult.Denied -> {
                        // pass
                    }
                    is PermissionUtils.Companion.PermissionResult.Granted -> {
                        // pass
                    }
                    is PermissionUtils.Companion.PermissionResult.AllGranted -> {
                        startActivityChooser(fileChooserParams, filePathCallback)
                    }
                }
            }
        }
    }

    
    override fun useCustomBackEvent(): Boolean = true

    override fun onBackEvent() {
        destroyWebView()
        super.onBackEvent()
    }

    private fun destroyWebView() {
        binding.llParent.removeAllViews()
        binding.webView.apply {
            clearHistory()
            clearCache(true)
            onPause()
            removeAllViews()
            destroyDrawingCache()
            destroy()
        }
    }
   

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        when (requestCode) {
            CHOOSE_FILE_REQUEST_CODE -> {
                var results: Array<Uri>? = null
                if (resultCode == Activity.RESULT_OK && mFilePathCallback!= null) {
                    if (data == null) { // take photo from camera
                        if (mCameraPhotoPath != null) results = arrayOf(Uri.parse(mCameraPhotoPath))
                    } else {  // image picker
                        data.dataString?.let { results = arrayOf(Uri.parse(it)) }
                    }
                }
                mFilePathCallback?.onReceiveValue(results)
                mFilePathCallback = null
            }
        }
        super.onActivityResult(requestCode, resultCode, data)
    }

    @Throws(IOException::class)
    private fun createImageFile(): File? {
        // Create an image file name
        val timeStamp: String = getTodayDateString()
        val imageFileName = "JPEG_" + timeStamp + "_"
        val storageDir: File = Environment.getExternalStoragePublicDirectory(
            Environment.DIRECTORY_PICTURES
        )
        return File.createTempFile(
            imageFileName,  /* prefix */
            ".jpg",  /* suffix */
            storageDir /* directory */
        )
    }

}