src/com/android/browser/FetchUrlMimeType.java

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.browser;
  18
  19 import android.content.ContentValues;
  20 import android.net.Uri;
  21 import com.android.common.AndroidHttpClient;
  22
  23 import org.apache.http.HttpResponse;
  24 import org.apache.http.Header;
  25 import org.apache.http.client.methods.HttpHead;
  26
  27 import java.io.IOException;
  28
  29 import android.os.AsyncTask;
  30 import android.provider.Downloads;
  31 import android.webkit.MimeTypeMap;
  32 import android.webkit.URLUtil;
  33
  34 /**
  35  * This class is used to pull down the http headers of a given URL so that
  36  * we can analyse the mimetype and make any correction needed before we give
  37  * the URL to the download manager. The ContentValues class holds the
  38  * content that would be provided to the download manager, so that on
  39  * completion of checking the mimetype, we can issue the download to
  40  * the download manager.
  41  * This operation is needed when the user long-clicks on a link or image and
  42  * we don't know the mimetype. If the user just clicks on the link, we will
  43  * do the same steps of correcting the mimetype down in
  44  * android.os.webkit.LoadListener rather than handling it here.
  45  *
  46  */
  47 class FetchUrlMimeType extends AsyncTask<ContentValues, String, String> {
  48
  49     BrowserActivity mActivity;
  50     ContentValues mValues;
  51
  52     public FetchUrlMimeType(BrowserActivity activity) {
  53         mActivity = activity;
  54     }
  55
  56     @Override
  57     public String doInBackground(ContentValues... values) {
  58         mValues = values[0];
  59
  60         // Check to make sure we have a URI to download
  61         String uri = mValues.getAsString(Downloads.COLUMN_URI);
  62         if (uri == null || uri.length() == 0) {
  63             return null;
  64         }
  65
  66         // User agent is likely to be null, though the AndroidHttpClient
  67         // seems ok with that.
  68         AndroidHttpClient client = AndroidHttpClient.newInstance(
  69                 mValues.getAsString(Downloads.COLUMN_USER_AGENT));
  70         HttpHead request = new HttpHead(uri);
  71
  72         String cookie = mValues.getAsString(Downloads.COLUMN_COOKIE_DATA);
  73         if (cookie != null && cookie.length() > 0) {
  74             request.addHeader("Cookie", cookie);
  75         }
  76
  77         String referer = mValues.getAsString(Downloads.COLUMN_REFERER);
  78         if (referer != null && referer.length() > 0) {
  79             request.addHeader("Referer", referer);
  80         }
  81
  82         HttpResponse response;
  83         String mimeType = null;
  84         try {
  85             response = client.execute(request);
  86             // We could get a redirect here, but if we do lets let
  87             // the download manager take care of it, and thus trust that
  88             // the server sends the right mimetype
  89             if (response.getStatusLine().getStatusCode() == 200) {
  90                 Header header = response.getFirstHeader("Content-Type");
  91                 if (header != null) {
  92                     mimeType = header.getValue();
  93                     final int semicolonIndex = mimeType.indexOf(';');
  94                     if (semicolonIndex != -1) {
  95                         mimeType = mimeType.substring(0, semicolonIndex);
  96                     }
  97                 }
  98             }
  99         } catch (IllegalArgumentException ex) {
 100             request.abort();
 101         } catch (IOException ex) {
 102             request.abort();
 103         } finally {
 104             client.close();
 105         }
 106
 107         return mimeType;
 108     }
 109
 110    @Override
 111     public void onPostExecute(String mimeType) {
 112        if (mimeType != null) {
 113            String url = mValues.getAsString(Downloads.COLUMN_URI);
 114            if (mimeType.equalsIgnoreCase("text/plain") ||
 115                    mimeType.equalsIgnoreCase("application/octet-stream")) {
 116                String newMimeType =
 117                        MimeTypeMap.getSingleton().getMimeTypeFromExtension(
 118                            MimeTypeMap.getFileExtensionFromUrl(url));
 119                if (newMimeType != null) {
 120                    mValues.put(Downloads.COLUMN_MIME_TYPE, newMimeType);
 121                }
 122            }
 123            String filename = URLUtil.guessFileName(url,
 124                    null, mimeType);
 125            mValues.put(Downloads.COLUMN_FILE_NAME_HINT, filename);
 126        }
 127
 128        // Start the download
 129        final Uri contentUri =
 130            mActivity.getContentResolver().insert(Downloads.CONTENT_URI, mValues);
 131        mActivity.viewDownloads(contentUri);
 132     }
 133
 134 }