title: "choose file to upload" on webview android kitkat 4.4.2
body: <p>I have a web view, I add the code to upload files and it works well on 4.3 and 4.2 (galaxy s3) , but it doesn't work on 4.4.2 like galaxy s5 and lg3.</p>
  
  <p>when I click on "choose file" it does not respond and nothing happens...</p>
  
  <p>this my code.</p>
  
  <p>MainActivity.java :</p>
  
  <pre><code>package com.com.myapplication;
  
  /**
   * Created by tadmitinteractive on 9/21/14.
   */
  
  import android.app.Activity;
  import android.app.AlertDialog;
  import android.app.ProgressDialog;
  import android.content.ActivityNotFoundException;
  import android.content.DialogInterface;
  import android.content.Intent;
  import android.graphics.Bitmap;
  import android.net.Uri;
  import android.os.Bundle;
  import android.os.Environment;
  import android.provider.MediaStore;
  import android.view.View;
  import android.webkit.JsResult;
  import android.webkit.ValueCallback;
  import android.webkit.WebChromeClient;
  import android.webkit.WebSettings;
  import android.webkit.WebSettings.PluginState;
  import android.webkit.WebView;
  import android.webkit.WebViewClient;
  import android.widget.ImageView;
  import android.widget.Toast;
  
  import java.io.File;
  import java.lang.reflect.Method;
  import java.net.URL;
  
  public class MainActivity extends Activity {
  
      @Override
      public void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.main);
          WebView webView = (WebView) findViewById(R.id.webview);
  
          String url="http://www.ipets.co.il/wp-login.php";
          initWebView(webView,url);
           // TODO input your url
  
      }
  
      private final static Object methodInvoke(Object obj, String method, Class&lt;?&gt;[] parameterTypes, Object[] args) {
          try {
              Method m = obj.getClass().getMethod(method, new Class[] { boolean.class });
              m.invoke(obj, args);
          } catch (Exception e) {
              e.printStackTrace();
          }
  
          return null;
      }
      private void initWebView(WebView view, String url) {
  
          WebSettings settings = view.getSettings();
          final WebView myWebView = (WebView) findViewById(R.id.webview);
          final ImageView imageView = (ImageView) findViewById(R.id.imageView);
          view.setWebViewClient(new WebViewClient());
          settings.setJavaScriptEnabled(true);
          settings.setAllowFileAccess(true);
          settings.setDomStorageEnabled(true);
          settings.setCacheMode(WebSettings.LOAD_NO_CACHE);
          settings.setLoadWithOverviewMode(true);
          settings.setUseWideViewPort(true);
          settings.setSupportZoom(true);
          // settings.setPluginsEnabled(true);
          methodInvoke(settings, "setPluginsEnabled", new Class[] { boolean.class }, new Object[] { true });
          // settings.setPluginState(PluginState.ON);
          methodInvoke(settings, "setPluginState", new Class[] { PluginState.class }, new Object[] { PluginState.ON });
          // settings.setPluginsEnabled(true);
          methodInvoke(settings, "setPluginsEnabled", new Class[] { boolean.class }, new Object[] { true });
          // settings.setAllowUniversalAccessFromFileURLs(true);
          methodInvoke(settings, "setAllowUniversalAccessFromFileURLs", new Class[] { boolean.class }, new Object[] { true });
          // settings.setAllowFileAccessFromFileURLs(true);
          methodInvoke(settings, "setAllowFileAccessFromFileURLs", new Class[] { boolean.class }, new Object[] { true });
  
          view.setScrollBarStyle(View.SCROLLBARS_INSIDE_OVERLAY);
          view.clearHistory();
          view.clearFormData();
          view.clearCache(true);
          view.loadUrl(url);
  
          view.setWebViewClient(new WebViewClient() {
              ProgressDialog dialog = new ProgressDialog(MainActivity.this);
  
  
              @Override
              public void onPageStarted(WebView view, String url,
                                        Bitmap favicon) {
                  // TODO Auto-generated method stub
  
                  dialog.setMessage("טוען...");
                  dialog.show();
                  super.onPageStarted(view, url, favicon);
              }
  
              @Override
              public void onPageFinished(WebView view, String url) {
                  // TODO Auto-generated method stub
                  myWebView.setVisibility(View.VISIBLE);
                  imageView.setVisibility(View.GONE);
  
  
                  dialog.dismiss();
                  super.onPageFinished(view, url);
  
              }
          });
  
          view.setWebChromeClient(new MyWebChromeClient());
          // webView.setDownloadListener(downloadListener);
  
      }
  
      UploadHandler mUploadHandler;
  
      @Override
      protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
  
          if (requestCode == Controller.FILE_SELECTED) {
              // Chose a file from the file picker.
              if (mUploadHandler != null) {
                  mUploadHandler.onResult(resultCode, intent);
              }
          }
  
          super.onActivityResult(requestCode, resultCode, intent);
      }
  
      class MyWebChromeClient extends WebChromeClient {
          public MyWebChromeClient() {
  
          }
  
          private String getTitleFromUrl(String url) {
              String title = url;
              try {
                  URL urlObj = new URL(url);
                  String host = urlObj.getHost();
                  if (host != null &amp;&amp; !host.isEmpty()) {
                      return urlObj.getProtocol() + "://" + host;
                  }
                  if (url.startsWith("file:")) {
                      String fileName = urlObj.getFile();
                      if (fileName != null &amp;&amp; !fileName.isEmpty()) {
                          return fileName;
                      }
                  }
              } catch (Exception e) {
                  // ignore
              }
  
              return title;
          }
  
          @Override
          public boolean onJsAlert(WebView view, String url, String message, final JsResult result) {
              String newTitle = getTitleFromUrl(url);
  
              new AlertDialog.Builder(MainActivity.this).setTitle(newTitle).setMessage(message).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
  
                  @Override
                  public void onClick(DialogInterface dialog, int which) {
                      result.confirm();
                  }
              }).setCancelable(false).create().show();
              return true;
              // return super.onJsAlert(view, url, message, result);
          }
  
          @Override
          public boolean onJsConfirm(WebView view, String url, String message, final JsResult result) {
  
              String newTitle = getTitleFromUrl(url);
  
              new AlertDialog.Builder(MainActivity.this).setTitle(newTitle).setMessage(message).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
  
                  @Override
                  public void onClick(DialogInterface dialog, int which) {
                      result.confirm();
                  }
              }).setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
                  public void onClick(DialogInterface dialog, int which) {
                      result.cancel();
                  }
              }).setCancelable(false).create().show();
              return true;
  
              // return super.onJsConfirm(view, url, message, result);
          }
  
          // Android 2.x
          public void openFileChooser(ValueCallback&lt;Uri&gt; uploadMsg) {
              openFileChooser(uploadMsg, "");
          }
  
          // Android 3.0
          public void openFileChooser(ValueCallback&lt;Uri&gt; uploadMsg, String acceptType) {
              openFileChooser(uploadMsg, "", "filesystem");
          }
  
          // Android 4.1
          public void openFileChooser(ValueCallback&lt;Uri&gt; uploadMsg, String acceptType, String capture) {
              mUploadHandler = new UploadHandler(new Controller());
              mUploadHandler.openFileChooser(uploadMsg, acceptType, capture);
          }
      };
  
      class Controller {
          final static int FILE_SELECTED = 4;
  
          Activity getActivity() {
              return MainActivity.this;
          }
      }
  
      // copied from android-4.4.3_r1/src/com/android/browser/UploadHandler.java
      //////////////////////////////////////////////////////////////////////
  
      /*
       * Copyright (C) 2010 The Android Open Source Project
       *
       * Licensed under the Apache License, Version 2.0 (the "License");
       * you may not use this file except in compliance with the License.
       * You may obtain a copy of the License at
       *
       *      http://www.apache.org/licenses/LICENSE-2.0
       *
       * Unless required by applicable law or agreed to in writing, software
       * distributed under the License is distributed on an "AS IS" BASIS,
       * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
       * See the License for the specific language governing permissions and
       * limitations under the License.
       */
  
      // package com.android.browser;
      //
      // import android.app.Activity;
      // import android.content.ActivityNotFoundException;
      // import android.content.Intent;
      // import android.net.Uri;
      // import android.os.Environment;
      // import android.provider.MediaStore;
      // import android.webkit.ValueCallback;
      // import android.widget.Toast;
      //
      // import java.io.File;
      // import java.util.Vector;
      //
      // /**
      // * Handle the file upload callbacks from WebView here
      // */
      // public class UploadHandler {
  
      class UploadHandler {
          /*
           * The Object used to inform the WebView of the file to upload.
           */
          private ValueCallback&lt;Uri&gt; mUploadMessage;
          private String mCameraFilePath;
          private boolean mHandled;
          private boolean mCaughtActivityNotFoundException;
          private Controller mController;
          public UploadHandler(Controller controller) {
              mController = controller;
          }
          String getFilePath() {
              return mCameraFilePath;
          }
          boolean handled() {
              return mHandled;
          }
          void onResult(int resultCode, Intent intent) {
              if (resultCode == Activity.RESULT_CANCELED &amp;&amp; mCaughtActivityNotFoundException) {
                  // Couldn't resolve an activity, we are going to try again so skip
                  // this result.
                  mCaughtActivityNotFoundException = false;
                  return;
              }
              Uri result = intent == null || resultCode != Activity.RESULT_OK ? null
                      : intent.getData();
              // As we ask the camera to save the result of the user taking
              // a picture, the camera application does not return anything other
              // than RESULT_OK. So we need to check whether the file we expected
              // was written to disk in the in the case that we
              // did not get an intent returned but did get a RESULT_OK. If it was,
              // we assume that this result has came back from the camera.
              if (result == null &amp;&amp; intent == null &amp;&amp; resultCode == Activity.RESULT_OK) {
                  File cameraFile = new File(mCameraFilePath);
                  if (cameraFile.exists()) {
                      result = Uri.fromFile(cameraFile);
                      // Broadcast to the media scanner that we have a new photo
                      // so it will be added into the gallery for the user.
                      mController.getActivity().sendBroadcast(
                              new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, result));
                  }
              }
              mUploadMessage.onReceiveValue(result);
              mHandled = true;
              mCaughtActivityNotFoundException = false;
          }
          void openFileChooser(ValueCallback&lt;Uri&gt; uploadMsg, String acceptType, String capture) {
              final String imageMimeType = "image/*";
              final String videoMimeType = "video/*";
              final String audioMimeType = "audio/*";
              final String mediaSourceKey = "capture";
              final String mediaSourceValueCamera = "camera";
              final String mediaSourceValueFileSystem = "filesystem";
              final String mediaSourceValueCamcorder = "camcorder";
              final String mediaSourceValueMicrophone = "microphone";
              // According to the spec, media source can be 'filesystem' or 'camera' or 'camcorder'
              // or 'microphone' and the default value should be 'filesystem'.
              String mediaSource = mediaSourceValueFileSystem;
              if (mUploadMessage != null) {
                  // Already a file picker operation in progress.
                  return;
              }
              mUploadMessage = uploadMsg;
              // Parse the accept type.
              String params[] = acceptType.split(";");
              String mimeType = params[0];
              if (capture.length() &gt; 0) {
                  mediaSource = capture;
              }
              if (capture.equals(mediaSourceValueFileSystem)) {
                  // To maintain backwards compatibility with the previous implementation
                  // of the media capture API, if the value of the 'capture' attribute is
                  // "filesystem", we should examine the accept-type for a MIME type that
                  // may specify a different capture value.
                  for (String p : params) {
                      String[] keyValue = p.split("=");
                      if (keyValue.length == 2) {
                          // Process key=value parameters.
                          if (mediaSourceKey.equals(keyValue[0])) {
                              mediaSource = keyValue[1];
                          }
                      }
                  }
              }
              //Ensure it is not still set from a previous upload.
              mCameraFilePath = null;
              if (mimeType.equals(imageMimeType)) {
                  if (mediaSource.equals(mediaSourceValueCamera)) {
                      // Specified 'image/*' and requested the camera, so go ahead and launch the
                      // camera directly.
                      startActivity(createCameraIntent());
                      return;
                  } else {
                      // Specified just 'image/*', capture=filesystem, or an invalid capture parameter.
                      // In all these cases we show a traditional picker filetered on accept type
                      // so launch an intent for both the Camera and image/* OPENABLE.
                      Intent chooser = createChooserIntent(createCameraIntent());
                      chooser.putExtra(Intent.EXTRA_INTENT, createOpenableIntent(imageMimeType));
                      startActivity(chooser);
                      return;
                  }
              } else if (mimeType.equals(videoMimeType)) {
                  if (mediaSource.equals(mediaSourceValueCamcorder)) {
                      // Specified 'video/*' and requested the camcorder, so go ahead and launch the
                      // camcorder directly.
                      startActivity(createCamcorderIntent());
                      return;
                  } else {
                      // Specified just 'video/*', capture=filesystem or an invalid capture parameter.
                      // In all these cases we show an intent for the traditional file picker, filtered
                      // on accept type so launch an intent for both camcorder and video/* OPENABLE.
                      Intent chooser = createChooserIntent(createCamcorderIntent());
                      chooser.putExtra(Intent.EXTRA_INTENT, createOpenableIntent(videoMimeType));
                      startActivity(chooser);
                      return;
                  }
              } else if (mimeType.equals(audioMimeType)) {
                  if (mediaSource.equals(mediaSourceValueMicrophone)) {
                      // Specified 'audio/*' and requested microphone, so go ahead and launch the sound
                      // recorder.
                      startActivity(createSoundRecorderIntent());
                      return;
                  } else {
                      // Specified just 'audio/*',  capture=filesystem of an invalid capture parameter.
                      // In all these cases so go ahead and launch an intent for both the sound
                      // recorder and audio/* OPENABLE.
                      Intent chooser = createChooserIntent(createSoundRecorderIntent());
                      chooser.putExtra(Intent.EXTRA_INTENT, createOpenableIntent(audioMimeType));
                      startActivity(chooser);
                      return;
                  }
              }
              // No special handling based on the accept type was necessary, so trigger the default
              // file upload chooser.
              startActivity(createDefaultOpenableIntent());
          }
          private void startActivity(Intent intent) {
              try {
                  mController.getActivity().startActivityForResult(intent, Controller.FILE_SELECTED);
              } catch (ActivityNotFoundException e) {
                  // No installed app was able to handle the intent that
                  // we sent, so fallback to the default file upload control.
                  try {
                      mCaughtActivityNotFoundException = true;
                      mController.getActivity().startActivityForResult(createDefaultOpenableIntent(),
                              Controller.FILE_SELECTED);
                  } catch (ActivityNotFoundException e2) {
                      // Nothing can return us a file, so file upload is effectively disabled.
                      Toast.makeText(mController.getActivity(), R.string.uploads_disabled,
                              Toast.LENGTH_LONG).show();
                  }
              }
          }
          private Intent createDefaultOpenableIntent() {
              // Create and return a chooser with the default OPENABLE
              // actions including the camera, camcorder and sound
              // recorder where available.
              Intent i = new Intent(Intent.ACTION_GET_CONTENT);
              i.addCategory(Intent.CATEGORY_OPENABLE);
              i.setType("*/*");
              Intent chooser = createChooserIntent(createCameraIntent(), createCamcorderIntent(),
                      createSoundRecorderIntent());
              chooser.putExtra(Intent.EXTRA_INTENT, i);
              return chooser;
          }
          private Intent createChooserIntent(Intent... intents) {
              Intent chooser = new Intent(Intent.ACTION_CHOOSER);
              chooser.putExtra(Intent.EXTRA_INITIAL_INTENTS, intents);
              chooser.putExtra(Intent.EXTRA_TITLE,
                      mController.getActivity().getResources()
                              .getString(R.string.choose_upload));
              return chooser;
          }
          private Intent createOpenableIntent(String type) {
              Intent i = new Intent(Intent.ACTION_GET_CONTENT);
              i.addCategory(Intent.CATEGORY_OPENABLE);
              i.setType(type);
              return i;
          }
          private Intent createCameraIntent() {
              Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
              File externalDataDir = Environment.getExternalStoragePublicDirectory(
                      Environment.DIRECTORY_DCIM);
              File cameraDataDir = new File(externalDataDir.getAbsolutePath() +
                      File.separator + "browser-photos");
              cameraDataDir.mkdirs();
              mCameraFilePath = cameraDataDir.getAbsolutePath() + File.separator +
                      System.currentTimeMillis() + ".jpg";
              cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(new File(mCameraFilePath)));
              return cameraIntent;
          }
          private Intent createCamcorderIntent() {
              return new Intent(MediaStore.ACTION_VIDEO_CAPTURE);
          }
          private Intent createSoundRecorderIntent() {
              return new Intent(MediaStore.Audio.Media.RECORD_SOUND_ACTION);
  
          }
  
      }
  
      @Override
      public void onBackPressed()
      {
          WebView webView = (WebView) findViewById(R.id.webview);
          if(webView.canGoBack()){
              webView.goBack();
          }else{
              super.onBackPressed();
          }
      }
  
  }
  </code></pre>