1 /* Copyright (C) 2011 The Android Open Source Project. 2 * 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 package com.android.exchange.adapter; 17 18 import android.content.ContentResolver; 19 import android.content.ContentValues; 20 import android.content.Context; 21 import android.net.Uri; 22 import android.os.RemoteException; 23 24 import com.android.emailcommon.provider.EmailContent.Attachment; 25 import com.android.emailcommon.provider.EmailContent.AttachmentColumns; 26 import com.android.emailcommon.provider.EmailContent.Message; 27 import com.android.emailcommon.service.EmailServiceStatus; 28 import com.android.emailcommon.utility.AttachmentUtilities; 29 import com.android.exchange.Eas; 30 import com.android.exchange.EasResponse; 31 import com.android.exchange.EasSyncService; 32 import com.android.exchange.ExchangeService; 33 import com.android.exchange.PartRequest; 34 import com.android.exchange.utility.UriCodec; 35 import com.google.common.annotations.VisibleForTesting; 36 37 import org.apache.http.HttpStatus; 38 39 import java.io.FileNotFoundException; 40 import java.io.IOException; 41 import java.io.InputStream; 42 import java.io.OutputStream; 43 44 /** 45 * Handle EAS attachment loading, regardless of protocol version 46 */ 47 public class AttachmentLoader { 48 static private final int CHUNK_SIZE = 16*1024; 49 50 private final EasSyncService mService; 51 private final Context mContext; 52 private final ContentResolver mResolver; 53 private final Attachment mAttachment; 54 private final long mAttachmentId; 55 private final int mAttachmentSize; 56 private final long mMessageId; 57 private final Message mMessage; 58 private final long mAccountId; 59 private final Uri mAttachmentUri; 60 AttachmentLoader(EasSyncService service, PartRequest req)61 public AttachmentLoader(EasSyncService service, PartRequest req) { 62 mService = service; 63 mContext = service.mContext; 64 mResolver = service.mContentResolver; 65 mAttachment = req.mAttachment; 66 mAttachmentId = mAttachment.mId; 67 mAttachmentSize = (int)mAttachment.mSize; 68 mAccountId = mAttachment.mAccountKey; 69 mMessageId = mAttachment.mMessageKey; 70 mMessage = Message.restoreMessageWithId(mContext, mMessageId); 71 mAttachmentUri = AttachmentUtilities.getAttachmentUri(mAccountId, mAttachmentId); 72 } 73 doStatusCallback(int status)74 private void doStatusCallback(int status) { 75 try { 76 ExchangeService.callback().loadAttachmentStatus(mMessageId, mAttachmentId, status, 0); 77 } catch (RemoteException e) { 78 // No danger if the client is no longer around 79 } 80 } 81 doProgressCallback(int progress)82 private void doProgressCallback(int progress) { 83 try { 84 ExchangeService.callback().loadAttachmentStatus(mMessageId, mAttachmentId, 85 EmailServiceStatus.IN_PROGRESS, progress); 86 } catch (RemoteException e) { 87 // No danger if the client is no longer around 88 } 89 } 90 91 /** 92 * Save away the contentUri for this Attachment and notify listeners 93 */ finishLoadAttachment()94 private void finishLoadAttachment() { 95 ContentValues cv = new ContentValues(); 96 cv.put(AttachmentColumns.CONTENT_URI, mAttachmentUri.toString()); 97 mAttachment.update(mContext, cv); 98 doStatusCallback(EmailServiceStatus.SUCCESS); 99 } 100 101 /** 102 * Read the attachment data in chunks and write the data back out to our attachment file 103 * @param inputStream the InputStream we're reading the attachment from 104 * @param outputStream the OutputStream the attachment will be written to 105 * @param len the number of expected bytes we're going to read 106 * @throws IOException 107 */ readChunked(InputStream inputStream, OutputStream outputStream, int len)108 public void readChunked(InputStream inputStream, OutputStream outputStream, int len) 109 throws IOException { 110 byte[] bytes = new byte[CHUNK_SIZE]; 111 int length = len; 112 // Loop terminates 1) when EOF is reached or 2) IOException occurs 113 // One of these is guaranteed to occur 114 int totalRead = 0; 115 int lastCallbackPct = -1; 116 int lastCallbackTotalRead = 0; 117 mService.userLog("Expected attachment length: ", len); 118 while (true) { 119 int read = inputStream.read(bytes, 0, CHUNK_SIZE); 120 if (read < 0) { 121 // -1 means EOF 122 mService.userLog("Attachment load reached EOF, totalRead: ", totalRead); 123 break; 124 } 125 126 // Keep track of how much we've read for progress callback 127 totalRead += read; 128 // Write these bytes out 129 outputStream.write(bytes, 0, read); 130 131 // We can't report percentage if data is chunked; the length of incoming data is unknown 132 if (length > 0) { 133 int pct = (totalRead * 100) / length; 134 // Callback only if we've read at least 1% more and have read more than CHUNK_SIZE 135 // We don't want to spam the Email app 136 if ((pct > lastCallbackPct) && (totalRead > (lastCallbackTotalRead + CHUNK_SIZE))) { 137 // Report progress back to the UI 138 doProgressCallback(pct); 139 lastCallbackTotalRead = totalRead; 140 lastCallbackPct = pct; 141 } 142 } 143 } 144 if (totalRead > length) { 145 // Apparently, the length, as reported by EAS, isn't always accurate; let's log it 146 mService.userLog("Read more than expected: ", totalRead); 147 } 148 } 149 150 @VisibleForTesting encodeForExchange2003(String str)151 static String encodeForExchange2003(String str) { 152 AttachmentNameEncoder enc = new AttachmentNameEncoder(); 153 StringBuilder sb = new StringBuilder(str.length() + 16); 154 enc.appendPartiallyEncoded(sb, str); 155 return sb.toString(); 156 } 157 158 /** 159 * Encoder for Exchange 2003 attachment names. They come from the server partially encoded, 160 * but there are still possible characters that need to be encoded (Why, MSFT, why?) 161 */ 162 private static class AttachmentNameEncoder extends UriCodec { isRetained(char c)163 @Override protected boolean isRetained(char c) { 164 // These four characters are commonly received in EAS 2.5 attachment names and are 165 // valid (verified by testing); we won't encode them 166 return c == '_' || c == ':' || c == '/' || c == '.'; 167 } 168 } 169 170 /** 171 * Loads an attachment, based on the PartRequest passed in the constructor 172 * @throws IOException 173 */ loadAttachment()174 public void loadAttachment() throws IOException { 175 if (mMessage == null) { 176 doStatusCallback(EmailServiceStatus.MESSAGE_NOT_FOUND); 177 return; 178 } 179 // Say we've started loading the attachment 180 doProgressCallback(0); 181 182 EasResponse resp; 183 boolean eas14 = mService.mProtocolVersionDouble >= Eas.SUPPORTED_PROTOCOL_EX2010_DOUBLE; 184 // The method of attachment loading is different in EAS 14.0 than in earlier versions 185 if (eas14) { 186 Serializer s = new Serializer(); 187 s.start(Tags.ITEMS_ITEMS).start(Tags.ITEMS_FETCH); 188 s.data(Tags.ITEMS_STORE, "Mailbox"); 189 s.data(Tags.BASE_FILE_REFERENCE, mAttachment.mLocation); 190 s.end().end().done(); // ITEMS_FETCH, ITEMS_ITEMS 191 resp = mService.sendHttpClientPost("ItemOperations", s.toByteArray()); 192 } else { 193 String location = mAttachment.mLocation; 194 // For Exchange 2003 (EAS 2.5), we have to look for illegal characters in the file name 195 // that EAS sent to us! 196 if (mService.mProtocolVersionDouble < Eas.SUPPORTED_PROTOCOL_EX2007_DOUBLE) { 197 location = encodeForExchange2003(location); 198 } 199 String cmd = "GetAttachment&AttachmentName=" + location; 200 resp = mService.sendHttpClientPost(cmd, null, EasSyncService.COMMAND_TIMEOUT); 201 } 202 203 try { 204 int status = resp.getStatus(); 205 if (status == HttpStatus.SC_OK) { 206 if (!resp.isEmpty()) { 207 InputStream is = resp.getInputStream(); 208 OutputStream os = null; 209 try { 210 os = mResolver.openOutputStream(mAttachmentUri); 211 if (eas14) { 212 ItemOperationsParser p = new ItemOperationsParser(this, is, os, 213 mAttachmentSize); 214 p.parse(); 215 if (p.getStatusCode() == 1 /* Success */) { 216 finishLoadAttachment(); 217 return; 218 } 219 } else { 220 int len = resp.getLength(); 221 if (len != 0) { 222 // len > 0 means that Content-Length was set in the headers 223 // len < 0 means "chunked" transfer-encoding 224 readChunked(is, os, (len < 0) ? mAttachmentSize : len); 225 finishLoadAttachment(); 226 return; 227 } 228 } 229 } catch (FileNotFoundException e) { 230 mService.errorLog("Can't get attachment; write file not found?"); 231 } finally { 232 if (os != null) { 233 os.flush(); 234 os.close(); 235 } 236 } 237 } 238 } 239 } finally { 240 resp.close(); 241 } 242 243 // All errors lead here... 244 doStatusCallback(EmailServiceStatus.ATTACHMENT_NOT_FOUND); 245 } 246 } 247