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.ComponentName;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.ActivityInfo;
import android.database.Cursor;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;
import android.webkit.ValueCallback;
import android.util.Log;
import android.widget.Toast;

import com.android.browser.R;
import com.android.browser.reflect.ReflectHelper;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

/**
 * Handle the file upload callbacks from WebView here
 */
public class UploadHandler {

    private static final String TAG = "UploadHandler";
    /*
     * The Object used to inform the WebView of the file to upload.
     */
    private ValueCallback<Uri> mUploadMessage;
    private ValueCallback<String[]> mUploadFilePaths;
    private String mCameraFilePath;

    private boolean mHandled;
    private boolean mCaughtActivityNotFoundException;

    private Controller mController;

    public UploadHandler(Controller controller) {
        mController = controller;
    }

    String getFilePath() {
        return mCameraFilePath;
    }

    protected boolean handled() {
        return mHandled;
    }

    protected void setHandled(boolean handled) {
        mHandled = handled;
        mCaughtActivityNotFoundException = false;
        if (!mHandled)
            mUploadFilePaths.onReceiveValue(null);
    }

    void onResult(int resultCode, Intent intent) {
        if (resultCode == Activity.RESULT_CANCELED && 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 && intent == null && 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));
            }
        }

        // try to get local file path from uri
        boolean hasGoodFilePath = false;
        String filePath = null;
        if (result != null) {
            String scheme = result.getScheme();
            if ("file".equals(scheme)) {
                filePath = result.getPath();
                hasGoodFilePath = filePath != null && !filePath.isEmpty();
            } else if ("content".equals(scheme)) {
                filePath = getFilePath(mController.getContext(), result);
                hasGoodFilePath = filePath != null && !filePath.isEmpty();
            }
        }

        // Add for carrier feature - prevent uploading DRM type files.
        boolean drmUploadEnabled = mController.getContext().getResources().getBoolean(
                                       R.bool.drm_uploads);
        boolean isDRMFileType = false;
        if (drmUploadEnabled && filePath != null
                && (filePath.endsWith(".fl") || filePath.endsWith(".dm")
                || filePath.endsWith(".dcf") || filePath.endsWith(".dr")
                || filePath.endsWith(".dd"))) {
            isDRMFileType = true;
            Toast.makeText(mController.getContext(), R.string.drm_file_unsupported,
                    Toast.LENGTH_LONG).show();
        }

        if (mUploadMessage != null) {

            if (!isDRMFileType) {
                mUploadMessage.onReceiveValue(result);
            } else {
                mUploadMessage.onReceiveValue(null);
            }
        }

        if (mUploadFilePaths != null) {
            if (hasGoodFilePath && !isDRMFileType) {
                Log.d(TAG, "upload file path:" + filePath);
                mUploadFilePaths.onReceiveValue(new String[]{filePath});
            } else {
                mUploadFilePaths.onReceiveValue(null);
            }
        }

        mHandled = true;
        mCaughtActivityNotFoundException = false;
    }


    public String getDocumentId(final Uri uri) {
        String id = null;
        try {
            Object[] params  = {(android.net.Uri)uri};
            Class[] type = new Class[] {Class.forName("android.net.Uri") };
            id = (String) ReflectHelper.invokeMethod(
                "android.provider.DocumentsContract","getDocumentId",
                type, params);

        } catch(java.lang.ClassNotFoundException e) {

        }
        return id;
    }


    public String getFilePath(final Context context, final Uri uri) {
       String id =  getDocumentId(uri);

        // DocumentProvider is new API exposed in Kitkat
        // Its a way of exposing unified file explorer
        if (id != null) {
            // ExternalStorageProvider
            if (isExternalStorageDocument(uri)) {
                final String docId = id;
                final String[] split = docId.split(":");
                final String type = split[0];

                if ("primary".equalsIgnoreCase(type)) {
                    return Environment.getExternalStorageDirectory() + "/" + split[1];
                }
            }
            // DownloadsProvider
            else if (isDownloadsDocument(uri)) {
                final Uri contentUri = ContentUris.withAppendedId(
                        Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
                return getDataColumn(context, contentUri, null, null);
            }
            // MediaProvider
            else if (isMediaDocument(uri)) {
                final String docId = id;
                final String[] split = docId.split(":");
                final String type = split[0];

                Uri contentUri = null;
                if ("image".equals(type)) {
                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
                } else if ("video".equals(type)) {
                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
                } else if ("audio".equals(type)) {
                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
                }

                final String selection = "_id=?";
                final String[] selectionArgs = new String[] {
                        split[1]
                };

                return getDataColumn(context, contentUri, selection, selectionArgs);
            }
        }
        // MediaStore (and general)
        else if ("content".equalsIgnoreCase(uri.getScheme())) {
            return getDataColumn(context, uri, null, null);
        }

        return null;
    }

    /**
    * Get the value of the data column for this Uri. This is useful for
    * MediaStore Uris, and other file-based ContentProviders.
    * @return The value of the _data column, which is typically a file path.
    */
    private String getDataColumn(Context context, Uri uri, String selection,
        String[] selectionArgs) {

        Cursor cursor = null;
        final String column = "_data";
        final String[] projection = { column };

        try {
            cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs,
                    null);
            if (cursor != null && cursor.moveToFirst()) {
                final int column_index = cursor.getColumnIndexOrThrow(column);
                return cursor.getString(column_index);
            }
        } finally {
            if (cursor != null)
                cursor.close();
        }
        return null;
    }

    /**
    * @return Whether the Uri authority is ExternalStorageProvider.
    */
    private boolean isExternalStorageDocument(Uri uri) {
        return "com.android.externalstorage.documents".equals(uri.getAuthority());
    }

    /**
    * @return Whether the Uri authority is DownloadsProvider.
    */
    private boolean isDownloadsDocument(Uri uri) {
        return "com.android.providers.downloads.documents".equals(uri.getAuthority());
    }

    /**
    * @return Whether the Uri authority is MediaProvider.
    */
    public static boolean isMediaDocument(Uri uri) {
        return "com.android.providers.media.documents".equals(uri.getAuthority());
    }


    void openFileChooser(ValueCallback<Uri> 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() > 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());
    }

    void showFileChooser(ValueCallback<String[]> uploadFilePaths, String acceptTypes,
            boolean capture) {

        final String imageMimeType = "image/*";
        final String videoMimeType = "video/*";
        final String audioMimeType = "audio/*";

        if (mUploadFilePaths != null) {
            // Already a file picker operation in progress.
            return;
        }

        mUploadFilePaths = uploadFilePaths;

        // Parse the accept type.
        String params[] = acceptTypes.split(";");
        String mimeType = params[0];

        // Ensure it is not still set from a previous upload.
        mCameraFilePath = null;
        List<Intent> intentList = new ArrayList<Intent>();

        if (mimeType.equals(imageMimeType)) {
            if (capture) {
                // Specified 'image/*' and capture=true, so go ahead and launch the
                // camera directly.
                startActivity(createCameraIntent());
                return;
            } else {
                // Specified just 'image/*', capture=false, or no capture value.
                // In all these cases we show a traditional picker filetered on accept type
                // so launch an intent for both the Camera and image/* OPENABLE.
                intentList.add(createCameraIntent());
                createUploadDialog(imageMimeType, intentList);
                return;
            }
        } else if (mimeType.equals(videoMimeType)) {
            if (capture) {
                // Specified 'video/*' and capture=true, so go ahead and launch the
                // camcorder directly.
                startActivity(createCamcorderIntent());
                return;
           } else {
                // Specified just 'video/*', capture=false, or no capture value.
                // 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.
                intentList.add(createCamcorderIntent());
                createUploadDialog(videoMimeType, intentList);
                return;
            }
        } else if (mimeType.equals(audioMimeType)) {
            if (capture) {
                // Specified 'audio/*' and capture=true, so go ahead and launch the sound
                // recorder.
                startActivity(createSoundRecorderIntent());
                return;
            } else {
                // Specified just 'audio/*',  capture=false, or no capture value.
                // In all these cases so go ahead and launch an intent for both the sound
                // recorder and audio/* OPENABLE.
                intentList.add(createSoundRecorderIntent());
                createUploadDialog(audioMimeType, intentList);
                return;
            }
        }

        // No special handling based on the accept type was necessary, so trigger the default
        // file upload chooser.
        createUploadDialog("*/*", null);
    }


    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 void createUploadDialog(String openableMimeType, List<Intent> intentList) {

        Intent openable = new Intent(Intent.ACTION_GET_CONTENT);
        openable.addCategory(Intent.CATEGORY_OPENABLE);
        openable.setType(openableMimeType);

        if (openableMimeType.equals("*/*") && intentList == null) {
            intentList = new ArrayList<Intent>();
            intentList.add(createCameraIntent());
            intentList.add(createCamcorderIntent());
            intentList.add(createSoundRecorderIntent());
        }

        PackageManager pm = mController.getActivity().getPackageManager();
        ArrayList<ResolveInfo> uploadApps = new ArrayList<ResolveInfo>();

        //Step 1:- resolve all apps for IntentList passed
        for (Intent i: intentList) {
            List<ResolveInfo> intentAppsList = pm.queryIntentActivities(i,
                                                    PackageManager.MATCH_DEFAULT_ONLY);
            // limit only to first activity
            uploadApps.add(intentAppsList.get(0));
        }

        // Step 2:- get all openable apps list and create corresponding intents
        List<ResolveInfo> openableAppsList = pm.queryIntentActivities(openable,
                                                PackageManager.MATCH_DEFAULT_ONLY);
        // limit only to first activity
        ResolveInfo topOpenableApp = openableAppsList.get(0);
        uploadApps.add(topOpenableApp);
        ActivityInfo activityInfo = topOpenableApp.activityInfo;
        ComponentName name = new ComponentName(activityInfo.applicationInfo.packageName,
                                    activityInfo.name);
        Intent i = new Intent(Intent.ACTION_GET_CONTENT);
        i.setType(openableMimeType);
        i.setComponent(name);
        intentList.add(i);

        // Step 3: Pass all the apps and their corresponding intents to uploaddialog
        UploadDialog upDialog = new UploadDialog(mController.getActivity());
        upDialog.getUploadableApps(uploadApps, intentList);
        upDialog.loadView(this);
    }

    public void initiateActivity(Intent intent) {
        startActivity(intent);
    }

    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);
    }

}