/* Copyright (C) 2011 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.exchange.adapter;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.net.Uri;
import android.os.RemoteException;
import com.android.emailcommon.provider.EmailContent.Attachment;
import com.android.emailcommon.provider.EmailContent.AttachmentColumns;
import com.android.emailcommon.provider.EmailContent.Message;
import com.android.emailcommon.service.EmailServiceStatus;
import com.android.emailcommon.utility.AttachmentUtilities;
import com.android.exchange.Eas;
import com.android.exchange.EasResponse;
import com.android.exchange.EasSyncService;
import com.android.exchange.ExchangeService;
import com.android.exchange.PartRequest;
import com.android.exchange.utility.UriCodec;
import com.google.common.annotations.VisibleForTesting;
import org.apache.http.HttpStatus;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* Handle EAS attachment loading, regardless of protocol version
*/
public class AttachmentLoader {
static private final int CHUNK_SIZE = 16*1024;
private final EasSyncService mService;
private final Context mContext;
private final ContentResolver mResolver;
private final Attachment mAttachment;
private final long mAttachmentId;
private final int mAttachmentSize;
private final long mMessageId;
private final Message mMessage;
private final long mAccountId;
private final Uri mAttachmentUri;
public AttachmentLoader(EasSyncService service, PartRequest req) {
mService = service;
mContext = service.mContext;
mResolver = service.mContentResolver;
mAttachment = req.mAttachment;
mAttachmentId = mAttachment.mId;
mAttachmentSize = (int)mAttachment.mSize;
mAccountId = mAttachment.mAccountKey;
mMessageId = mAttachment.mMessageKey;
mMessage = Message.restoreMessageWithId(mContext, mMessageId);
mAttachmentUri = AttachmentUtilities.getAttachmentUri(mAccountId, mAttachmentId);
}
private void doStatusCallback(int status) {
try {
ExchangeService.callback().loadAttachmentStatus(mMessageId, mAttachmentId, status, 0);
} catch (RemoteException e) {
// No danger if the client is no longer around
}
}
private void doProgressCallback(int progress) {
try {
ExchangeService.callback().loadAttachmentStatus(mMessageId, mAttachmentId,
EmailServiceStatus.IN_PROGRESS, progress);
} catch (RemoteException e) {
// No danger if the client is no longer around
}
}
/**
* Save away the contentUri for this Attachment and notify listeners
*/
private void finishLoadAttachment() {
ContentValues cv = new ContentValues();
cv.put(AttachmentColumns.CONTENT_URI, mAttachmentUri.toString());
mAttachment.update(mContext, cv);
doStatusCallback(EmailServiceStatus.SUCCESS);
}
/**
* Read the attachment data in chunks and write the data back out to our attachment file
* @param inputStream the InputStream we're reading the attachment from
* @param outputStream the OutputStream the attachment will be written to
* @param len the number of expected bytes we're going to read
* @throws IOException
*/
public void readChunked(InputStream inputStream, OutputStream outputStream, int len)
throws IOException {
byte[] bytes = new byte[CHUNK_SIZE];
int length = len;
// Loop terminates 1) when EOF is reached or 2) IOException occurs
// One of these is guaranteed to occur
int totalRead = 0;
int lastCallbackPct = -1;
int lastCallbackTotalRead = 0;
mService.userLog("Expected attachment length: ", len);
while (true) {
int read = inputStream.read(bytes, 0, CHUNK_SIZE);
if (read < 0) {
// -1 means EOF
mService.userLog("Attachment load reached EOF, totalRead: ", totalRead);
break;
}
// Keep track of how much we've read for progress callback
totalRead += read;
// Write these bytes out
outputStream.write(bytes, 0, read);
// We can't report percentage if data is chunked; the length of incoming data is unknown
if (length > 0) {
int pct = (totalRead * 100) / length;
// Callback only if we've read at least 1% more and have read more than CHUNK_SIZE
// We don't want to spam the Email app
if ((pct > lastCallbackPct) && (totalRead > (lastCallbackTotalRead + CHUNK_SIZE))) {
// Report progress back to the UI
doProgressCallback(pct);
lastCallbackTotalRead = totalRead;
lastCallbackPct = pct;
}
}
}
if (totalRead > length) {
// Apparently, the length, as reported by EAS, isn't always accurate; let's log it
mService.userLog("Read more than expected: ", totalRead);
}
}
@VisibleForTesting
static String encodeForExchange2003(String str) {
AttachmentNameEncoder enc = new AttachmentNameEncoder();
StringBuilder sb = new StringBuilder(str.length() + 16);
enc.appendPartiallyEncoded(sb, str);
return sb.toString();
}
/**
* Encoder for Exchange 2003 attachment names. They come from the server partially encoded,
* but there are still possible characters that need to be encoded (Why, MSFT, why?)
*/
private static class AttachmentNameEncoder extends UriCodec {
@Override protected boolean isRetained(char c) {
// These four characters are commonly received in EAS 2.5 attachment names and are
// valid (verified by testing); we won't encode them
return c == '_' || c == ':' || c == '/' || c == '.';
}
}
/**
* Loads an attachment, based on the PartRequest passed in the constructor
* @throws IOException
*/
public void loadAttachment() throws IOException {
if (mMessage == null) {
doStatusCallback(EmailServiceStatus.MESSAGE_NOT_FOUND);
return;
}
// Say we've started loading the attachment
doProgressCallback(0);
EasResponse resp;
boolean eas14 = mService.mProtocolVersionDouble >= Eas.SUPPORTED_PROTOCOL_EX2010_DOUBLE;
// The method of attachment loading is different in EAS 14.0 than in earlier versions
if (eas14) {
Serializer s = new Serializer();
s.start(Tags.ITEMS_ITEMS).start(Tags.ITEMS_FETCH);
s.data(Tags.ITEMS_STORE, "Mailbox");
s.data(Tags.BASE_FILE_REFERENCE, mAttachment.mLocation);
s.end().end().done(); // ITEMS_FETCH, ITEMS_ITEMS
resp = mService.sendHttpClientPost("ItemOperations", s.toByteArray());
} else {
String location = mAttachment.mLocation;
// For Exchange 2003 (EAS 2.5), we have to look for illegal characters in the file name
// that EAS sent to us!
if (mService.mProtocolVersionDouble < Eas.SUPPORTED_PROTOCOL_EX2007_DOUBLE) {
location = encodeForExchange2003(location);
}
String cmd = "GetAttachment&AttachmentName=" + location;
resp = mService.sendHttpClientPost(cmd, null, EasSyncService.COMMAND_TIMEOUT);
}
try {
int status = resp.getStatus();
if (status == HttpStatus.SC_OK) {
if (!resp.isEmpty()) {
InputStream is = resp.getInputStream();
OutputStream os = null;
try {
os = mResolver.openOutputStream(mAttachmentUri);
if (eas14) {
ItemOperationsParser p = new ItemOperationsParser(this, is, os,
mAttachmentSize);
p.parse();
if (p.getStatusCode() == 1 /* Success */) {
finishLoadAttachment();
return;
}
} else {
int len = resp.getLength();
if (len != 0) {
// len > 0 means that Content-Length was set in the headers
// len < 0 means "chunked" transfer-encoding
readChunked(is, os, (len < 0) ? mAttachmentSize : len);
finishLoadAttachment();
return;
}
}
} catch (FileNotFoundException e) {
mService.errorLog("Can't get attachment; write file not found?");
} finally {
if (os != null) {
os.flush();
os.close();
}
}
}
}
} finally {
resp.close();
}
// All errors lead here...
doStatusCallback(EmailServiceStatus.ATTACHMENT_NOT_FOUND);
}
}