/* * Copyright (C) 2009 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.contacts.common.vcard; import android.app.Activity; import android.app.AlertDialog; import android.app.Dialog; import android.app.Notification; import android.app.NotificationManager; import android.app.ProgressDialog; import android.content.ClipData; import android.content.ComponentName; import android.content.ContentResolver; import android.content.Context; import android.content.DialogInterface; import android.content.Intent; import android.content.ServiceConnection; import android.database.Cursor; import android.net.Uri; import android.os.Bundle; import android.os.Handler; import android.os.IBinder; import android.os.PowerManager; import android.provider.OpenableColumns; import android.text.TextUtils; import android.util.Log; import android.widget.Toast; import com.android.contacts.common.R; import com.android.contacts.common.activity.RequestImportVCardPermissionsActivity; import com.android.contacts.common.model.AccountTypeManager; import com.android.contacts.common.model.account.AccountWithDataSet; import com.android.vcard.VCardEntryCounter; import com.android.vcard.VCardParser; import com.android.vcard.VCardParser_V21; import com.android.vcard.VCardParser_V30; import com.android.vcard.VCardSourceDetector; import com.android.vcard.exception.VCardException; import com.android.vcard.exception.VCardNestedException; import com.android.vcard.exception.VCardVersionException; import java.io.ByteArrayInputStream; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.nio.ByteBuffer; import java.nio.channels.Channels; import java.nio.channels.ReadableByteChannel; import java.nio.channels.WritableByteChannel; import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * The class letting users to import vCard. This includes the UI part for letting them select * an Account and posssibly a file if there's no Uri is given from its caller Activity. * * Note that this Activity assumes that the instance is a "one-shot Activity", which will be * finished (with the method {@link Activity#finish()}) after the import and never reuse * any Dialog in the instance. So this code is careless about the management around managed * dialogs stuffs (like how onCreateDialog() is used). */ public class ImportVCardActivity extends Activity { private static final String LOG_TAG = "VCardImport"; private static final int SELECT_ACCOUNT = 0; /* package */ final static int VCARD_VERSION_AUTO_DETECT = 0; /* package */ final static int VCARD_VERSION_V21 = 1; /* package */ final static int VCARD_VERSION_V30 = 2; private static final int REQUEST_OPEN_DOCUMENT = 100; /** * Notification id used when error happened before sending an import request to VCardServer. */ private static final int FAILURE_NOTIFICATION_ID = 1; private AccountWithDataSet mAccount; private ProgressDialog mProgressDialogForCachingVCard; private VCardCacheThread mVCardCacheThread; private ImportRequestConnection mConnection; /* package */ VCardImportExportListener mListener; private String mErrorMessage; private Handler mHandler = new Handler(); // Runs on the UI thread. private class DialogDisplayer implements Runnable { private final int mResId; public DialogDisplayer(int resId) { mResId = resId; } public DialogDisplayer(String errorMessage) { mResId = R.id.dialog_error_with_message; mErrorMessage = errorMessage; } @Override public void run() { if (!isFinishing()) { showDialog(mResId); } } } private class CancelListener implements DialogInterface.OnClickListener, DialogInterface.OnCancelListener { @Override public void onClick(DialogInterface dialog, int which) { finish(); } @Override public void onCancel(DialogInterface dialog) { finish(); } } private CancelListener mCancelListener = new CancelListener(); private class ImportRequestConnection implements ServiceConnection { private VCardService mService; public void sendImportRequest(final List requests) { Log.i(LOG_TAG, "Send an import request"); mService.handleImportRequest(requests, mListener); } @Override public void onServiceConnected(ComponentName name, IBinder binder) { mService = ((VCardService.MyBinder) binder).getService(); Log.i(LOG_TAG, String.format("Connected to VCardService. Kick a vCard cache thread (uri: %s)", Arrays.toString(mVCardCacheThread.getSourceUris()))); mVCardCacheThread.start(); } @Override public void onServiceDisconnected(ComponentName name) { Log.i(LOG_TAG, "Disconnected from VCardService"); } } /** * Caches given vCard files into a local directory, and sends actual import request to * {@link VCardService}. * * We need to cache given files into local storage. One of reasons is that some data (as Uri) * may have special permissions. Callers may allow only this Activity to access that content, * not what this Activity launched (like {@link VCardService}). */ private class VCardCacheThread extends Thread implements DialogInterface.OnCancelListener { private boolean mCanceled; private PowerManager.WakeLock mWakeLock; private VCardParser mVCardParser; private final Uri[] mSourceUris; // Given from a caller. private final byte[] mSource; private final String mDisplayName; public VCardCacheThread(final Uri[] sourceUris) { mSourceUris = sourceUris; mSource = null; final Context context = ImportVCardActivity.this; final PowerManager powerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE); mWakeLock = powerManager.newWakeLock( PowerManager.SCREEN_DIM_WAKE_LOCK | PowerManager.ON_AFTER_RELEASE, LOG_TAG); mDisplayName = null; } @Override public void finalize() { if (mWakeLock != null && mWakeLock.isHeld()) { Log.w(LOG_TAG, "WakeLock is being held."); mWakeLock.release(); } } @Override public void run() { Log.i(LOG_TAG, "vCard cache thread starts running."); if (mConnection == null) { throw new NullPointerException("vCard cache thread must be launched " + "after a service connection is established"); } mWakeLock.acquire(); try { if (mCanceled == true) { Log.i(LOG_TAG, "vCard cache operation is canceled."); return; } final Context context = ImportVCardActivity.this; // Uris given from caller applications may not be opened twice: consider when // it is not from local storage (e.g. "file:///...") but from some special // provider (e.g. "content://..."). // Thus we have to once copy the content of Uri into local storage, and read // it after it. // // We may be able to read content of each vCard file during copying them // to local storage, but currently vCard code does not allow us to do so. int cache_index = 0; ArrayList requests = new ArrayList(); if (mSource != null) { try { requests.add(constructImportRequest(mSource, null, mDisplayName)); } catch (VCardException e) { Log.e(LOG_TAG, "Maybe the file is in wrong format", e); showFailureNotification(R.string.fail_reason_not_supported); return; } } else { final ContentResolver resolver = ImportVCardActivity.this.getContentResolver(); for (Uri sourceUri : mSourceUris) { String filename = null; // Note: caches are removed by VCardService. while (true) { filename = VCardService.CACHE_FILE_PREFIX + cache_index + ".vcf"; final File file = context.getFileStreamPath(filename); if (!file.exists()) { break; } else { if (cache_index == Integer.MAX_VALUE) { throw new RuntimeException("Exceeded cache limit"); } cache_index++; } } Uri localDataUri = null; try { localDataUri = copyTo(sourceUri, filename); } catch (SecurityException e) { Log.e(LOG_TAG, "SecurityException", e); showFailureNotification(R.string.fail_reason_io_error); return; } if (mCanceled) { Log.i(LOG_TAG, "vCard cache operation is canceled."); break; } if (localDataUri == null) { Log.w(LOG_TAG, "destUri is null"); break; } String displayName = null; Cursor cursor = null; // Try to get a display name from the given Uri. If it fails, we just // pick up the last part of the Uri. try { cursor = resolver.query(sourceUri, new String[] { OpenableColumns.DISPLAY_NAME }, null, null, null); if (cursor != null && cursor.getCount() > 0 && cursor.moveToFirst()) { if (cursor.getCount() > 1) { Log.w(LOG_TAG, "Unexpected multiple rows: " + cursor.getCount()); } int index = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME); if (index >= 0) { displayName = cursor.getString(index); } } } finally { if (cursor != null) { cursor.close(); } } if (TextUtils.isEmpty(displayName)){ displayName = sourceUri.getLastPathSegment(); } final ImportRequest request; try { request = constructImportRequest(null, localDataUri, displayName); } catch (VCardException e) { Log.e(LOG_TAG, "Maybe the file is in wrong format", e); showFailureNotification(R.string.fail_reason_not_supported); return; } catch (IOException e) { Log.e(LOG_TAG, "Unexpected IOException", e); showFailureNotification(R.string.fail_reason_io_error); return; } if (mCanceled) { Log.i(LOG_TAG, "vCard cache operation is canceled."); return; } requests.add(request); } } if (!requests.isEmpty()) { mConnection.sendImportRequest(requests); } else { Log.w(LOG_TAG, "Empty import requests. Ignore it."); } } catch (OutOfMemoryError e) { Log.e(LOG_TAG, "OutOfMemoryError occured during caching vCard"); System.gc(); runOnUiThread(new DialogDisplayer( getString(R.string.fail_reason_low_memory_during_import))); } catch (IOException e) { Log.e(LOG_TAG, "IOException during caching vCard", e); runOnUiThread(new DialogDisplayer( getString(R.string.fail_reason_io_error))); } finally { Log.i(LOG_TAG, "Finished caching vCard."); mWakeLock.release(); unbindService(mConnection); mProgressDialogForCachingVCard.dismiss(); mProgressDialogForCachingVCard = null; finish(); } } /** * Copy the content of sourceUri to the destination. */ private Uri copyTo(final Uri sourceUri, String filename) throws IOException { Log.i(LOG_TAG, String.format("Copy a Uri to app local storage (%s -> %s)", sourceUri, filename)); final Context context = ImportVCardActivity.this; final ContentResolver resolver = context.getContentResolver(); ReadableByteChannel inputChannel = null; WritableByteChannel outputChannel = null; Uri destUri = null; try { inputChannel = Channels.newChannel(resolver.openInputStream(sourceUri)); destUri = Uri.parse(context.getFileStreamPath(filename).toURI().toString()); outputChannel = context.openFileOutput(filename, Context.MODE_PRIVATE).getChannel(); final ByteBuffer buffer = ByteBuffer.allocateDirect(8192); while (inputChannel.read(buffer) != -1) { if (mCanceled) { Log.d(LOG_TAG, "Canceled during caching " + sourceUri); return null; } buffer.flip(); outputChannel.write(buffer); buffer.compact(); } buffer.flip(); while (buffer.hasRemaining()) { outputChannel.write(buffer); } } finally { if (inputChannel != null) { try { inputChannel.close(); } catch (IOException e) { Log.w(LOG_TAG, "Failed to close inputChannel."); } } if (outputChannel != null) { try { outputChannel.close(); } catch(IOException e) { Log.w(LOG_TAG, "Failed to close outputChannel"); } } } return destUri; } /** * Reads localDataUri (possibly multiple times) and constructs {@link ImportRequest} from * its content. * * @arg localDataUri Uri actually used for the import. Should be stored in * app local storage, as we cannot guarantee other types of Uris can be read * multiple times. This variable populates {@link ImportRequest#uri}. * @arg displayName Used for displaying information to the user. This variable populates * {@link ImportRequest#displayName}. */ private ImportRequest constructImportRequest(final byte[] data, final Uri localDataUri, final String displayName) throws IOException, VCardException { final ContentResolver resolver = ImportVCardActivity.this.getContentResolver(); VCardEntryCounter counter = null; VCardSourceDetector detector = null; int vcardVersion = VCARD_VERSION_V21; try { boolean shouldUseV30 = false; InputStream is; if (data != null) { is = new ByteArrayInputStream(data); } else { is = resolver.openInputStream(localDataUri); } mVCardParser = new VCardParser_V21(); try { counter = new VCardEntryCounter(); detector = new VCardSourceDetector(); mVCardParser.addInterpreter(counter); mVCardParser.addInterpreter(detector); mVCardParser.parse(is); } catch (VCardVersionException e1) { try { is.close(); } catch (IOException e) { } shouldUseV30 = true; if (data != null) { is = new ByteArrayInputStream(data); } else { is = resolver.openInputStream(localDataUri); } mVCardParser = new VCardParser_V30(); try { counter = new VCardEntryCounter(); detector = new VCardSourceDetector(); mVCardParser.addInterpreter(counter); mVCardParser.addInterpreter(detector); mVCardParser.parse(is); } catch (VCardVersionException e2) { throw new VCardException("vCard with unspported version."); } } finally { if (is != null) { try { is.close(); } catch (IOException e) { } } } vcardVersion = shouldUseV30 ? VCARD_VERSION_V30 : VCARD_VERSION_V21; } catch (VCardNestedException e) { Log.w(LOG_TAG, "Nested Exception is found (it may be false-positive)."); // Go through without throwing the Exception, as we may be able to detect the // version before it } return new ImportRequest(mAccount, data, localDataUri, displayName, detector.getEstimatedType(), detector.getEstimatedCharset(), vcardVersion, counter.getCount()); } public Uri[] getSourceUris() { return mSourceUris; } public void cancel() { mCanceled = true; if (mVCardParser != null) { mVCardParser.cancel(); } } @Override public void onCancel(DialogInterface dialog) { Log.i(LOG_TAG, "Cancel request has come. Abort caching vCard."); cancel(); } } private void importVCard(final Uri uri) { importVCard(new Uri[] {uri}); } private void importVCard(final Uri[] uris) { runOnUiThread(new Runnable() { @Override public void run() { if (!isFinishing()) { mVCardCacheThread = new VCardCacheThread(uris); mListener = new NotificationImportExportListener(ImportVCardActivity.this); showDialog(R.id.dialog_cache_vcard); } } }); } @Override protected void onCreate(Bundle bundle) { super.onCreate(bundle); if (RequestImportVCardPermissionsActivity.startPermissionActivity(this)) { return; } String accountName = null; String accountType = null; String dataSet = null; final Intent intent = getIntent(); if (intent != null) { accountName = intent.getStringExtra(SelectAccountActivity.ACCOUNT_NAME); accountType = intent.getStringExtra(SelectAccountActivity.ACCOUNT_TYPE); dataSet = intent.getStringExtra(SelectAccountActivity.DATA_SET); } else { Log.e(LOG_TAG, "intent does not exist"); } if (!TextUtils.isEmpty(accountName) && !TextUtils.isEmpty(accountType)) { mAccount = new AccountWithDataSet(accountName, accountType, dataSet); } else { final AccountTypeManager accountTypes = AccountTypeManager.getInstance(this); final List accountList = accountTypes.getAccounts(true); if (accountList.size() == 0) { mAccount = null; } else if (accountList.size() == 1) { mAccount = accountList.get(0); } else { startActivityForResult(new Intent(this, SelectAccountActivity.class), SELECT_ACCOUNT); return; } } startImport(); } @Override public void onActivityResult(int requestCode, int resultCode, Intent intent) { if (requestCode == SELECT_ACCOUNT) { if (resultCode == Activity.RESULT_OK) { mAccount = new AccountWithDataSet( intent.getStringExtra(SelectAccountActivity.ACCOUNT_NAME), intent.getStringExtra(SelectAccountActivity.ACCOUNT_TYPE), intent.getStringExtra(SelectAccountActivity.DATA_SET)); startImport(); } else { if (resultCode != Activity.RESULT_CANCELED) { Log.w(LOG_TAG, "Result code was not OK nor CANCELED: " + resultCode); } finish(); } } else if (requestCode == REQUEST_OPEN_DOCUMENT) { if (resultCode == Activity.RESULT_OK) { final ClipData clipData = intent.getClipData(); if (clipData != null) { final ArrayList uris = new ArrayList<>(); for (int i = 0; i < clipData.getItemCount(); i++) { ClipData.Item item = clipData.getItemAt(i); final Uri uri = item.getUri(); if (uri != null) { uris.add(uri); } } if (uris.isEmpty()) { Log.w(LOG_TAG, "No vCard was selected for import"); finish(); } else { Log.i(LOG_TAG, "Multiple vCards selected for import: " + uris); importVCard(uris.toArray(new Uri[0])); } } else { final Uri uri = intent.getData(); if (uri != null) { Log.i(LOG_TAG, "vCard selected for import: " + uri); importVCard(uri); } else { Log.w(LOG_TAG, "No vCard was selected for import"); finish(); } } } else { if (resultCode != Activity.RESULT_CANCELED) { Log.w(LOG_TAG, "Result code was not OK nor CANCELED" + resultCode); } finish(); } } } private void startImport() { // Handle inbound files Uri uri = getIntent().getData(); if (uri != null) { Log.i(LOG_TAG, "Starting vCard import using Uri " + uri); importVCard(uri); } else { Log.i(LOG_TAG, "Start vCard without Uri. The user will select vCard manually."); final Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT); intent.addCategory(Intent.CATEGORY_OPENABLE); intent.setType(VCardService.X_VCARD_MIME_TYPE); intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true); intent.putExtra(Intent.EXTRA_LOCAL_ONLY, true); startActivityForResult(intent, REQUEST_OPEN_DOCUMENT); } } @Override protected Dialog onCreateDialog(int resId, Bundle bundle) { switch (resId) { case R.id.dialog_cache_vcard: { if (mProgressDialogForCachingVCard == null) { final String title = getString(R.string.caching_vcard_title); final String message = getString(R.string.caching_vcard_message); mProgressDialogForCachingVCard = new ProgressDialog(this); mProgressDialogForCachingVCard.setTitle(title); mProgressDialogForCachingVCard.setMessage(message); mProgressDialogForCachingVCard.setProgressStyle(ProgressDialog.STYLE_SPINNER); mProgressDialogForCachingVCard.setOnCancelListener(mVCardCacheThread); startVCardService(); } return mProgressDialogForCachingVCard; } case R.id.dialog_error_with_message: { String message = mErrorMessage; if (TextUtils.isEmpty(message)) { Log.e(LOG_TAG, "Error message is null while it must not."); message = getString(R.string.fail_reason_unknown); } final AlertDialog.Builder builder = new AlertDialog.Builder(this) .setTitle(getString(R.string.reading_vcard_failed_title)) .setIconAttribute(android.R.attr.alertDialogIcon) .setMessage(message) .setOnCancelListener(mCancelListener) .setPositiveButton(android.R.string.ok, mCancelListener); return builder.create(); } } return super.onCreateDialog(resId, bundle); } /* package */ void startVCardService() { mConnection = new ImportRequestConnection(); Log.i(LOG_TAG, "Bind to VCardService."); // We don't want the service finishes itself just after this connection. Intent intent = new Intent(this, VCardService.class); startService(intent); bindService(new Intent(this, VCardService.class), mConnection, Context.BIND_AUTO_CREATE); } @Override protected void onRestoreInstanceState(Bundle savedInstanceState) { super.onRestoreInstanceState(savedInstanceState); if (mProgressDialogForCachingVCard != null) { Log.i(LOG_TAG, "Cache thread is still running. Show progress dialog again."); showDialog(R.id.dialog_cache_vcard); } } /* package */ void showFailureNotification(int reasonId) { final NotificationManager notificationManager = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE); final Notification notification = NotificationImportExportListener.constructImportFailureNotification( ImportVCardActivity.this, getString(reasonId)); notificationManager.notify(NotificationImportExportListener.FAILURE_NOTIFICATION_TAG, FAILURE_NOTIFICATION_ID, notification); mHandler.post(new Runnable() { @Override public void run() { Toast.makeText(ImportVCardActivity.this, getString(R.string.vcard_import_failed), Toast.LENGTH_LONG).show(); } }); } }