1 /* 2 * Copyright (C) 2010 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 package com.android.contacts.common.vcard; 17 18 import android.accounts.Account; 19 import android.content.ContentResolver; 20 import android.net.Uri; 21 import android.util.Log; 22 23 import com.android.vcard.VCardEntry; 24 import com.android.vcard.VCardEntryCommitter; 25 import com.android.vcard.VCardEntryConstructor; 26 import com.android.vcard.VCardEntryHandler; 27 import com.android.vcard.VCardInterpreter; 28 import com.android.vcard.VCardParser; 29 import com.android.vcard.VCardParser_V21; 30 import com.android.vcard.VCardParser_V30; 31 import com.android.vcard.exception.VCardException; 32 import com.android.vcard.exception.VCardNestedException; 33 import com.android.vcard.exception.VCardNotSupportedException; 34 import com.android.vcard.exception.VCardVersionException; 35 36 import java.io.ByteArrayInputStream; 37 import java.io.IOException; 38 import java.io.InputStream; 39 import java.util.ArrayList; 40 import java.util.List; 41 42 /** 43 * Class for processing one import request from a user. Dropped after importing requested Uri(s). 44 * {@link VCardService} will create another object when there is another import request. 45 */ 46 public class ImportProcessor extends ProcessorBase implements VCardEntryHandler { 47 private static final String LOG_TAG = "VCardImport"; 48 private static final boolean DEBUG = VCardService.DEBUG; 49 50 private final VCardService mService; 51 private final ContentResolver mResolver; 52 private final ImportRequest mImportRequest; 53 private final int mJobId; 54 private final VCardImportExportListener mListener; 55 56 // TODO: remove and show appropriate message instead. 57 private final List<Uri> mFailedUris = new ArrayList<Uri>(); 58 59 private VCardParser mVCardParser; 60 61 private volatile boolean mCanceled; 62 private volatile boolean mDone; 63 64 private int mCurrentCount = 0; 65 private int mTotalCount = 0; 66 67 public ImportProcessor(final VCardService service, final VCardImportExportListener listener, 68 final ImportRequest request, final int jobId) { 69 mService = service; 70 mResolver = mService.getContentResolver(); 71 mListener = listener; 72 73 mImportRequest = request; 74 mJobId = jobId; 75 } 76 77 @Override 78 public void onStart() { 79 // do nothing 80 } 81 82 @Override 83 public void onEnd() { 84 // do nothing 85 } 86 87 @Override 88 public void onEntryCreated(VCardEntry entry) { 89 mCurrentCount++; 90 if (mListener != null) { 91 mListener.onImportParsed(mImportRequest, mJobId, entry, mCurrentCount, mTotalCount); 92 } 93 } 94 95 @Override 96 public final int getType() { 97 return VCardService.TYPE_IMPORT; 98 } 99 100 @Override 101 public void run() { 102 // ExecutorService ignores RuntimeException, so we need to show it here. 103 try { 104 runInternal(); 105 106 if (isCancelled() && mListener != null) { 107 mListener.onImportCanceled(mImportRequest, mJobId); 108 } 109 } catch (OutOfMemoryError e) { 110 Log.e(LOG_TAG, "OutOfMemoryError thrown during import", e); 111 throw e; 112 } catch (RuntimeException e) { 113 Log.e(LOG_TAG, "RuntimeException thrown during import", e); 114 throw e; 115 } finally { 116 synchronized (this) { 117 mDone = true; 118 } 119 } 120 } 121 122 private void runInternal() { 123 Log.i(LOG_TAG, String.format("vCard import (id: %d) has started.", mJobId)); 124 final ImportRequest request = mImportRequest; 125 if (isCancelled()) { 126 Log.i(LOG_TAG, "Canceled before actually handling parameter (" + request.uri + ")"); 127 return; 128 } 129 final int[] possibleVCardVersions; 130 if (request.vcardVersion == ImportVCardActivity.VCARD_VERSION_AUTO_DETECT) { 131 /** 132 * Note: this code assumes that a given Uri is able to be opened more than once, 133 * which may not be true in certain conditions. 134 */ 135 possibleVCardVersions = new int[] { 136 ImportVCardActivity.VCARD_VERSION_V21, 137 ImportVCardActivity.VCARD_VERSION_V30 138 }; 139 } else { 140 possibleVCardVersions = new int[] { 141 request.vcardVersion 142 }; 143 } 144 145 final Uri uri = request.uri; 146 final Account account = request.account; 147 final int estimatedVCardType = request.estimatedVCardType; 148 final String estimatedCharset = request.estimatedCharset; 149 final int entryCount = request.entryCount; 150 mTotalCount += entryCount; 151 152 final VCardEntryConstructor constructor = 153 new VCardEntryConstructor(estimatedVCardType, account, estimatedCharset); 154 final VCardEntryCommitter committer = new VCardEntryCommitter(mResolver); 155 constructor.addEntryHandler(committer); 156 constructor.addEntryHandler(this); 157 158 InputStream is = null; 159 boolean successful = false; 160 try { 161 if (uri != null) { 162 Log.i(LOG_TAG, "start importing one vCard (Uri: " + uri + ")"); 163 is = mResolver.openInputStream(uri); 164 } else if (request.data != null){ 165 Log.i(LOG_TAG, "start importing one vCard (byte[])"); 166 is = new ByteArrayInputStream(request.data); 167 } 168 169 if (is != null) { 170 successful = readOneVCard(is, estimatedVCardType, estimatedCharset, constructor, 171 possibleVCardVersions); 172 } 173 } catch (IOException e) { 174 successful = false; 175 } finally { 176 if (is != null) { 177 try { 178 is.close(); 179 } catch (Exception e) { 180 // ignore 181 } 182 } 183 } 184 185 mService.handleFinishImportNotification(mJobId, successful); 186 187 if (successful) { 188 // TODO: successful becomes true even when cancelled. Should return more appropriate 189 // value 190 if (isCancelled()) { 191 Log.i(LOG_TAG, "vCard import has been canceled (uri: " + uri + ")"); 192 // Cancel notification will be done outside this method. 193 } else { 194 Log.i(LOG_TAG, "Successfully finished importing one vCard file: " + uri); 195 List<Uri> uris = committer.getCreatedUris(); 196 if (mListener != null) { 197 if (uris != null && uris.size() == 1) { 198 mListener.onImportFinished(mImportRequest, mJobId, uris.get(0)); 199 } else { 200 if (uris == null || uris.size() == 0) { 201 // Not critical, but suspicious. 202 Log.w(LOG_TAG, "Created Uris is null or 0 length " + 203 "though the creation itself is successful."); 204 } 205 mListener.onImportFinished(mImportRequest, mJobId, null); 206 } 207 } 208 } 209 } else { 210 Log.w(LOG_TAG, "Failed to read one vCard file: " + uri); 211 mFailedUris.add(uri); 212 } 213 } 214 215 private boolean readOneVCard(InputStream is, int vcardType, String charset, 216 final VCardInterpreter interpreter, 217 final int[] possibleVCardVersions) { 218 boolean successful = false; 219 final int length = possibleVCardVersions.length; 220 for (int i = 0; i < length; i++) { 221 final int vcardVersion = possibleVCardVersions[i]; 222 try { 223 if (i > 0 && (interpreter instanceof VCardEntryConstructor)) { 224 // Let the object clean up internal temporary objects, 225 ((VCardEntryConstructor) interpreter).clear(); 226 } 227 228 // We need synchronized block here, 229 // since we need to handle mCanceled and mVCardParser at once. 230 // In the worst case, a user may call cancel() just before creating 231 // mVCardParser. 232 synchronized (this) { 233 mVCardParser = (vcardVersion == ImportVCardActivity.VCARD_VERSION_V30 ? 234 new VCardParser_V30(vcardType) : 235 new VCardParser_V21(vcardType)); 236 if (isCancelled()) { 237 Log.i(LOG_TAG, "ImportProcessor already recieves cancel request, so " + 238 "send cancel request to vCard parser too."); 239 mVCardParser.cancel(); 240 } 241 } 242 mVCardParser.parse(is, interpreter); 243 244 successful = true; 245 break; 246 } catch (IOException e) { 247 Log.e(LOG_TAG, "IOException was emitted: " + e.getMessage()); 248 } catch (VCardNestedException e) { 249 // This exception should not be thrown here. We should instead handle it 250 // in the preprocessing session in ImportVCardActivity, as we don't try 251 // to detect the type of given vCard here. 252 // 253 // TODO: Handle this case appropriately, which should mean we have to have 254 // code trying to auto-detect the type of given vCard twice (both in 255 // ImportVCardActivity and ImportVCardService). 256 Log.e(LOG_TAG, "Nested Exception is found."); 257 } catch (VCardNotSupportedException e) { 258 Log.e(LOG_TAG, e.toString()); 259 } catch (VCardVersionException e) { 260 if (i == length - 1) { 261 Log.e(LOG_TAG, "Appropriate version for this vCard is not found."); 262 } else { 263 // We'll try the other (v30) version. 264 } 265 } catch (VCardException e) { 266 Log.e(LOG_TAG, e.toString()); 267 } finally { 268 if (is != null) { 269 try { 270 is.close(); 271 } catch (IOException e) { 272 } 273 } 274 } 275 } 276 277 return successful; 278 } 279 280 @Override 281 public synchronized boolean cancel(boolean mayInterruptIfRunning) { 282 if (DEBUG) Log.d(LOG_TAG, "ImportProcessor received cancel request"); 283 if (mDone || mCanceled) { 284 return false; 285 } 286 mCanceled = true; 287 synchronized (this) { 288 if (mVCardParser != null) { 289 mVCardParser.cancel(); 290 } 291 } 292 return true; 293 } 294 295 @Override 296 public synchronized boolean isCancelled() { 297 return mCanceled; 298 } 299 300 301 @Override 302 public synchronized boolean isDone() { 303 return mDone; 304 } 305 } 306
