1package com.android.nfc.handover;
2
3import android.app.Notification;
4import android.app.NotificationManager;
5import android.app.PendingIntent;
6import android.app.Notification.Builder;
7import android.bluetooth.BluetoothDevice;
8import android.content.ContentResolver;
9import android.content.Context;
10import android.content.Intent;
11import android.media.MediaScannerConnection;
12import android.net.Uri;
13import android.os.Environment;
14import android.os.Handler;
15import android.os.Looper;
16import android.os.Message;
17import android.os.SystemClock;
18import android.os.UserHandle;
19import android.util.Log;
20
21import com.android.nfc.R;
22
23import java.io.File;
24import java.text.SimpleDateFormat;
25import java.util.ArrayList;
26import java.util.Date;
27import java.util.HashMap;
28import java.util.Locale;
29
30/**
31 * A HandoverTransfer object represents a set of files
32 * that were received through NFC connection handover
33 * from the same source address.
34 *
35 * For Bluetooth, files are received through OPP, and
36 * we have no knowledge how many files will be transferred
37 * as part of a single transaction.
38 * Hence, a transfer has a notion of being "alive": if
39 * the last update to a transfer was within WAIT_FOR_NEXT_TRANSFER_MS
40 * milliseconds, we consider a new file transfer from the
41 * same source address as part of the same transfer.
42 * The corresponding URIs will be grouped in a single folder.
43 *
44 */
45public class HandoverTransfer implements Handler.Callback,
46        MediaScannerConnection.OnScanCompletedListener {
47
48    interface Callback {
49        void onTransferComplete(HandoverTransfer transfer, boolean success);
50    };
51
52    static final String TAG = "HandoverTransfer";
53
54    static final Boolean DBG = true;
55
56    // In the states below we still accept new file transfer
57    static final int STATE_NEW = 0;
58    static final int STATE_IN_PROGRESS = 1;
59    static final int STATE_W4_NEXT_TRANSFER = 2;
60
61    // In the states below no new files are accepted.
62    static final int STATE_W4_MEDIA_SCANNER = 3;
63    static final int STATE_FAILED = 4;
64    static final int STATE_SUCCESS = 5;
65    static final int STATE_CANCELLED = 6;
66
67    static final int MSG_NEXT_TRANSFER_TIMER = 0;
68    static final int MSG_TRANSFER_TIMEOUT = 1;
69
70    // We need to receive an update within this time period
71    // to still consider this transfer to be "alive" (ie
72    // a reason to keep the handover transport enabled).
73    static final int ALIVE_CHECK_MS = 20000;
74
75    // The amount of time to wait for a new transfer
76    // once the current one completes.
77    static final int WAIT_FOR_NEXT_TRANSFER_MS = 4000;
78
79    static final String BEAM_DIR = "beam";
80
81    final boolean mIncoming;  // whether this is an incoming transfer
82    final int mTransferId; // Unique ID of this transfer used for notifications
83    final PendingIntent mCancelIntent;
84    final Context mContext;
85    final Handler mHandler;
86    final NotificationManager mNotificationManager;
87    final BluetoothDevice mRemoteDevice;
88    final Callback mCallback;
89
90    // Variables below are only accessed on the main thread
91    int mState;
92    int mCurrentCount;
93    int mSuccessCount;
94    int mTotalCount;
95    boolean mCalledBack;
96    Long mLastUpdate; // Last time an event occurred for this transfer
97    float mProgress; // Progress in range [0..1]
98    ArrayList<Uri> mBtUris; // Received uris from Bluetooth OPP
99    ArrayList<String> mBtMimeTypes; // Mime-types received from Bluetooth OPP
100
101    ArrayList<String> mPaths; // Raw paths on the filesystem for Beam-stored files
102    HashMap<String, String> mMimeTypes; // Mime-types associated with each path
103    HashMap<String, Uri> mMediaUris; // URIs found by the media scanner for each path
104    int mUrisScanned;
105
106    public HandoverTransfer(Context context, Callback callback,
107            PendingHandoverTransfer pendingTransfer) {
108        mContext = context;
109        mCallback = callback;
110        mRemoteDevice = pendingTransfer.remoteDevice;
111        mIncoming = pendingTransfer.incoming;
112        mTransferId = pendingTransfer.id;
113        // For incoming transfers, count can be set later
114        mTotalCount = (pendingTransfer.uris != null) ? pendingTransfer.uris.length : 0;
115        mLastUpdate = SystemClock.elapsedRealtime();
116        mProgress = 0.0f;
117        mState = STATE_NEW;
118        mBtUris = new ArrayList<Uri>();
119        mBtMimeTypes = new ArrayList<String>();
120        mPaths = new ArrayList<String>();
121        mMimeTypes = new HashMap<String, String>();
122        mMediaUris = new HashMap<String, Uri>();
123        mCancelIntent = buildCancelIntent(mIncoming);
124        mUrisScanned = 0;
125        mCurrentCount = 0;
126        mSuccessCount = 0;
127
128        mHandler = new Handler(Looper.getMainLooper(), this);
129        mHandler.sendEmptyMessageDelayed(MSG_TRANSFER_TIMEOUT, ALIVE_CHECK_MS);
130        mNotificationManager = (NotificationManager) mContext.getSystemService(
131                Context.NOTIFICATION_SERVICE);
132    }
133
134    void whitelistOppDevice(BluetoothDevice device) {
135        if (DBG) Log.d(TAG, "Whitelisting " + device + " for BT OPP");
136        Intent intent = new Intent(HandoverManager.ACTION_WHITELIST_DEVICE);
137        intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
138        mContext.sendBroadcastAsUser(intent, UserHandle.CURRENT);
139    }
140
141    public void updateFileProgress(float progress) {
142        if (!isRunning()) return; // Ignore when we're no longer running
143
144        mHandler.removeMessages(MSG_NEXT_TRANSFER_TIMER);
145
146        this.mProgress = progress;
147
148        // We're still receiving data from this device - keep it in
149        // the whitelist for a while longer
150        if (mIncoming) whitelistOppDevice(mRemoteDevice);
151
152        updateStateAndNotification(STATE_IN_PROGRESS);
153    }
154
155    public void finishTransfer(boolean success, Uri uri, String mimeType) {
156        if (!isRunning()) return; // Ignore when we're no longer running
157
158        mCurrentCount++;
159        if (success && uri != null) {
160            mSuccessCount++;
161            if (DBG) Log.d(TAG, "Transfer success, uri " + uri + " mimeType " + mimeType);
162            mProgress = 0.0f;
163            if (mimeType == null) {
164                mimeType = BluetoothOppHandover.getMimeTypeForUri(mContext, uri);
165            }
166            if (mimeType != null) {
167                mBtUris.add(uri);
168                mBtMimeTypes.add(mimeType);
169            } else {
170                if (DBG) Log.d(TAG, "Could not get mimeType for file.");
171            }
172        } else {
173            Log.e(TAG, "Handover transfer failed");
174            // Do wait to see if there's another file coming.
175        }
176        mHandler.removeMessages(MSG_NEXT_TRANSFER_TIMER);
177        if (mCurrentCount == mTotalCount) {
178            if (mIncoming) {
179                processFiles();
180            } else {
181                updateStateAndNotification(mSuccessCount > 0 ? STATE_SUCCESS : STATE_FAILED);
182            }
183        } else {
184            mHandler.sendEmptyMessageDelayed(MSG_NEXT_TRANSFER_TIMER, WAIT_FOR_NEXT_TRANSFER_MS);
185            updateStateAndNotification(STATE_W4_NEXT_TRANSFER);
186        }
187    }
188
189    public boolean isRunning() {
190        if (mState != STATE_NEW && mState != STATE_IN_PROGRESS && mState != STATE_W4_NEXT_TRANSFER) {
191            return false;
192        } else {
193            return true;
194        }
195    }
196
197    public void setObjectCount(int objectCount) {
198        mTotalCount = objectCount;
199    }
200
201    void cancel() {
202        if (!isRunning()) return;
203
204        // Delete all files received so far
205        for (Uri uri : mBtUris) {
206            File file = new File(uri.getPath());
207            if (file.exists()) file.delete();
208        }
209
210        updateStateAndNotification(STATE_CANCELLED);
211    }
212
213    void updateNotification() {
214        Builder notBuilder = new Notification.Builder(mContext);
215
216        String beamString;
217        if (mIncoming) {
218            beamString = mContext.getString(R.string.beam_progress);
219        } else {
220            beamString = mContext.getString(R.string.beam_outgoing);
221        }
222        if (mState == STATE_NEW || mState == STATE_IN_PROGRESS ||
223                mState == STATE_W4_NEXT_TRANSFER || mState == STATE_W4_MEDIA_SCANNER) {
224            notBuilder.setAutoCancel(false);
225            notBuilder.setSmallIcon(mIncoming ? android.R.drawable.stat_sys_download :
226                    android.R.drawable.stat_sys_upload);
227            notBuilder.setTicker(beamString);
228            notBuilder.setContentTitle(beamString);
229            notBuilder.addAction(R.drawable.ic_menu_cancel_holo_dark,
230                    mContext.getString(R.string.cancel), mCancelIntent);
231            float progress = 0;
232            if (mTotalCount > 0) {
233                float progressUnit = 1.0f / mTotalCount;
234                progress = (float) mCurrentCount * progressUnit + mProgress * progressUnit;
235            }
236            if (mTotalCount > 0 && progress > 0) {
237                notBuilder.setProgress(100, (int) (100 * progress), false);
238            } else {
239                notBuilder.setProgress(100, 0, true);
240            }
241        } else if (mState == STATE_SUCCESS) {
242            notBuilder.setAutoCancel(true);
243            notBuilder.setSmallIcon(mIncoming ? android.R.drawable.stat_sys_download_done :
244                    android.R.drawable.stat_sys_upload_done);
245            notBuilder.setTicker(mContext.getString(R.string.beam_complete));
246            notBuilder.setContentTitle(mContext.getString(R.string.beam_complete));
247
248            if (mIncoming) {
249                notBuilder.setContentText(mContext.getString(R.string.beam_touch_to_view));
250                Intent viewIntent = buildViewIntent();
251                PendingIntent contentIntent = PendingIntent.getActivity(
252                        mContext, mTransferId, viewIntent, 0, null);
253
254                notBuilder.setContentIntent(contentIntent);
255            }
256        } else if (mState == STATE_FAILED) {
257            notBuilder.setAutoCancel(false);
258            notBuilder.setSmallIcon(mIncoming ? android.R.drawable.stat_sys_download_done :
259                    android.R.drawable.stat_sys_upload_done);
260            notBuilder.setTicker(mContext.getString(R.string.beam_failed));
261            notBuilder.setContentTitle(mContext.getString(R.string.beam_failed));
262        } else if (mState == STATE_CANCELLED) {
263            notBuilder.setAutoCancel(false);
264            notBuilder.setSmallIcon(mIncoming ? android.R.drawable.stat_sys_download_done :
265                    android.R.drawable.stat_sys_upload_done);
266            notBuilder.setTicker(mContext.getString(R.string.beam_canceled));
267            notBuilder.setContentTitle(mContext.getString(R.string.beam_canceled));
268        } else {
269            return;
270        }
271
272        mNotificationManager.notify(null, mTransferId, notBuilder.build());
273    }
274
275    void updateStateAndNotification(int newState) {
276        this.mState = newState;
277        this.mLastUpdate = SystemClock.elapsedRealtime();
278
279        if (mHandler.hasMessages(MSG_TRANSFER_TIMEOUT)) {
280            // Update timeout timer
281            mHandler.removeMessages(MSG_TRANSFER_TIMEOUT);
282            mHandler.sendEmptyMessageDelayed(MSG_TRANSFER_TIMEOUT, ALIVE_CHECK_MS);
283        }
284
285        updateNotification();
286
287        if ((mState == STATE_SUCCESS || mState == STATE_FAILED || mState == STATE_CANCELLED)
288                && !mCalledBack) {
289            mCalledBack = true;
290            // Notify that we're done with this transfer
291            mCallback.onTransferComplete(this, mState == STATE_SUCCESS);
292        }
293    }
294
295    void processFiles() {
296        // Check the amount of files we received in this transfer;
297        // If more than one, create a separate directory for it.
298        String extRoot = Environment.getExternalStorageDirectory().getPath();
299        File beamPath = new File(extRoot + "/" + BEAM_DIR);
300
301        if (!checkMediaStorage(beamPath) || mBtUris.size() == 0) {
302            Log.e(TAG, "Media storage not valid or no uris received.");
303            updateStateAndNotification(STATE_FAILED);
304            return;
305        }
306
307        if (mBtUris.size() > 1) {
308            beamPath = generateMultiplePath(extRoot + "/" + BEAM_DIR + "/");
309            if (!beamPath.isDirectory() && !beamPath.mkdir()) {
310                Log.e(TAG, "Failed to create multiple path " + beamPath.toString());
311                updateStateAndNotification(STATE_FAILED);
312                return;
313            }
314        }
315
316        for (int i = 0; i < mBtUris.size(); i++) {
317            Uri uri = mBtUris.get(i);
318            String mimeType = mBtMimeTypes.get(i);
319
320            File srcFile = new File(uri.getPath());
321
322            File dstFile = generateUniqueDestination(beamPath.getAbsolutePath(),
323                    uri.getLastPathSegment());
324            if (!srcFile.renameTo(dstFile)) {
325                if (DBG) Log.d(TAG, "Failed to rename from " + srcFile + " to " + dstFile);
326                srcFile.delete();
327                return;
328            } else {
329                mPaths.add(dstFile.getAbsolutePath());
330                mMimeTypes.put(dstFile.getAbsolutePath(), mimeType);
331                if (DBG) Log.d(TAG, "Did successful rename from " + srcFile + " to " + dstFile);
332            }
333        }
334
335        // We can either add files to the media provider, or provide an ACTION_VIEW
336        // intent to the file directly. We base this decision on the mime type
337        // of the first file; if it's media the platform can deal with,
338        // use the media provider, if it's something else, just launch an ACTION_VIEW
339        // on the file.
340        String mimeType = mMimeTypes.get(mPaths.get(0));
341        if (mimeType.startsWith("image/") || mimeType.startsWith("video/") ||
342                mimeType.startsWith("audio/")) {
343            String[] arrayPaths = new String[mPaths.size()];
344            MediaScannerConnection.scanFile(mContext, mPaths.toArray(arrayPaths), null, this);
345            updateStateAndNotification(STATE_W4_MEDIA_SCANNER);
346        } else {
347            // We're done.
348            updateStateAndNotification(STATE_SUCCESS);
349        }
350
351    }
352
353    public int getTransferId() {
354        return mTransferId;
355    }
356
357    public boolean handleMessage(Message msg) {
358        if (msg.what == MSG_NEXT_TRANSFER_TIMER) {
359            // We didn't receive a new transfer in time, finalize this one
360            if (mIncoming) {
361                processFiles();
362            } else {
363                updateStateAndNotification(mSuccessCount > 0 ? STATE_SUCCESS : STATE_FAILED);
364            }
365            return true;
366        } else if (msg.what == MSG_TRANSFER_TIMEOUT) {
367            // No update on this transfer for a while, check
368            // to see if it's still running, and fail it if it is.
369            if (isRunning()) {
370                if (DBG) Log.d(TAG, "Transfer timed out");
371                updateStateAndNotification(STATE_FAILED);
372            }
373        }
374        return false;
375    }
376
377    public synchronized void onScanCompleted(String path, Uri uri) {
378        if (DBG) Log.d(TAG, "Scan completed, path " + path + " uri " + uri);
379        if (uri != null) {
380            mMediaUris.put(path, uri);
381        }
382        mUrisScanned++;
383        if (mUrisScanned == mPaths.size()) {
384            // We're done
385            updateStateAndNotification(STATE_SUCCESS);
386        }
387    }
388
389    boolean checkMediaStorage(File path) {
390        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
391            if (!path.isDirectory() && !path.mkdir()) {
392                Log.e(TAG, "Not dir or not mkdir " + path.getAbsolutePath());
393                return false;
394            }
395            return true;
396        } else {
397            Log.e(TAG, "External storage not mounted, can't store file.");
398            return false;
399        }
400    }
401
402    Intent buildViewIntent() {
403        if (mPaths.size() == 0) return null;
404
405        Intent viewIntent = new Intent(Intent.ACTION_VIEW);
406
407        String filePath = mPaths.get(0);
408        Uri mediaUri = mMediaUris.get(filePath);
409        Uri uri =  mediaUri != null ? mediaUri :
410            Uri.parse(ContentResolver.SCHEME_FILE + "://" + filePath);
411        viewIntent.setDataAndTypeAndNormalize(uri, mMimeTypes.get(filePath));
412        viewIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
413        return viewIntent;
414    }
415
416    PendingIntent buildCancelIntent(boolean incoming) {
417        Intent intent = new Intent(HandoverService.ACTION_CANCEL_HANDOVER_TRANSFER);
418        intent.putExtra(HandoverService.EXTRA_SOURCE_ADDRESS, mRemoteDevice.getAddress());
419        intent.putExtra(HandoverService.EXTRA_INCOMING, incoming ? 1 : 0);
420        PendingIntent pi = PendingIntent.getBroadcast(mContext, mTransferId, intent,
421                PendingIntent.FLAG_ONE_SHOT);
422
423        return pi;
424    }
425
426    File generateUniqueDestination(String path, String fileName) {
427        int dotIndex = fileName.lastIndexOf(".");
428        String extension = null;
429        String fileNameWithoutExtension = null;
430        if (dotIndex < 0) {
431            extension = "";
432            fileNameWithoutExtension = fileName;
433        } else {
434            extension = fileName.substring(dotIndex);
435            fileNameWithoutExtension = fileName.substring(0, dotIndex);
436        }
437        File dstFile = new File(path + File.separator + fileName);
438        int count = 0;
439        while (dstFile.exists()) {
440            dstFile = new File(path + File.separator + fileNameWithoutExtension + "-" +
441                    Integer.toString(count) + extension);
442            count++;
443        }
444        return dstFile;
445    }
446
447    File generateMultiplePath(String beamRoot) {
448        // Generate a unique directory with the date
449        String format = "yyyy-MM-dd";
450        SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.US);
451        String newPath = beamRoot + "beam-" + sdf.format(new Date());
452        File newFile = new File(newPath);
453        int count = 0;
454        while (newFile.exists()) {
455            newPath = beamRoot + "beam-" + sdf.format(new Date()) + "-" +
456                    Integer.toString(count);
457            newFile = new File(newPath);
458            count++;
459        }
460        return newFile;
461    }
462}
463
464