| /* |
| * Copyright (C) 2013 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.bluetooth.mapapi; |
| |
| import android.content.ContentProvider; |
| import android.content.ContentResolver; |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.content.UriMatcher; |
| import android.content.pm.ProviderInfo; |
| import android.database.Cursor; |
| import android.net.Uri; |
| import android.os.AsyncTask; |
| import android.os.Binder; |
| import android.os.Bundle; |
| import android.os.ParcelFileDescriptor; |
| import android.util.Log; |
| |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * A base implementation of the BluetoothMapEmailContract. |
| * A base class for a ContentProvider that allows access to Email messages from a Bluetooth |
| * device through the Message Access Profile. |
| */ |
| public abstract class BluetoothMapEmailProvider extends ContentProvider { |
| |
| private static final String TAG = "BluetoothMapEmailProvider"; |
| private static final boolean D = true; |
| |
| private static final int MATCH_ACCOUNT = 1; |
| private static final int MATCH_MESSAGE = 2; |
| private static final int MATCH_FOLDER = 3; |
| |
| protected ContentResolver mResolver; |
| |
| private Uri CONTENT_URI = null; |
| private String mAuthority; |
| private UriMatcher mMatcher; |
| |
| |
| private PipeReader mPipeReader = new PipeReader(); |
| private PipeWriter mPipeWriter = new PipeWriter(); |
| |
| /** |
| * Write the content of a message to a stream as MIME encoded RFC-2822 data. |
| * @param accountId the ID of the account to which the message belong |
| * @param messageId the ID of the message to write to the stream |
| * @param includeAttachment true if attachments should be included |
| * @param download true if any missing part of the message shall be downloaded |
| * before written to the stream. The download flag will determine |
| * whether or not attachments shall be downloaded or only the message content. |
| * @param out the FileOurputStream to write to. |
| * @throws IOException |
| */ |
| protected abstract void WriteMessageToStream(long accountId, long messageId, |
| boolean includeAttachment, boolean download, FileOutputStream out) throws IOException; |
| |
| /** |
| * @return the CONTENT_URI exposed. This will be used to send out notifications. |
| */ |
| protected abstract Uri getContentUri(); |
| |
| /** |
| * Implementation is provided by the parent class. |
| */ |
| @Override |
| public void attachInfo(Context context, ProviderInfo info) { |
| mAuthority = info.authority; |
| |
| mMatcher = new UriMatcher(UriMatcher.NO_MATCH); |
| mMatcher.addURI(mAuthority, BluetoothMapContract.TABLE_ACCOUNT, MATCH_ACCOUNT); |
| mMatcher.addURI(mAuthority, "#/" + BluetoothMapContract.TABLE_FOLDER, MATCH_FOLDER); |
| mMatcher.addURI(mAuthority, "#/" + BluetoothMapContract.TABLE_MESSAGE, MATCH_MESSAGE); |
| |
| // Sanity check our setup |
| if (!info.exported) { |
| throw new SecurityException("Provider must be exported"); |
| } |
| // Enforce correct permissions are used |
| if (!android.Manifest.permission.BLUETOOTH_MAP.equals(info.writePermission)) { |
| throw new SecurityException( |
| "Provider must be protected by " + android.Manifest.permission.BLUETOOTH_MAP); |
| } |
| mResolver = context.getContentResolver(); |
| super.attachInfo(context, info); |
| } |
| |
| |
| /** |
| * Interface to write a stream of data to a pipe. Use with |
| * {@link ContentProvider#openPipeHelper}. |
| */ |
| public interface PipeDataReader<T> { |
| /** |
| * Called from a background thread to stream data from a pipe. |
| * Note that the pipe is blocking, so this thread can block on |
| * reads for an arbitrary amount of time if the client is slow |
| * at writing. |
| * |
| * @param input The pipe where data should be read. This will be |
| * closed for you upon returning from this function. |
| * @param uri The URI whose data is to be written. |
| * @param mimeType The desired type of data to be written. |
| * @param opts Options supplied by caller. |
| * @param args Your own custom arguments. |
| */ |
| void readDataFromPipe(ParcelFileDescriptor input, Uri uri, String mimeType, Bundle opts, |
| T args); |
| } |
| |
| public class PipeReader implements PipeDataReader<Cursor> { |
| /** |
| * Read the data from the pipe and generate a message. |
| * Use the message to do an update of the message specified by the URI. |
| */ |
| @Override |
| public void readDataFromPipe(ParcelFileDescriptor input, Uri uri, String mimeType, |
| Bundle opts, Cursor args) { |
| Log.v(TAG, "readDataFromPipe(): uri=" + uri.toString()); |
| FileInputStream fIn = null; |
| try { |
| fIn = new FileInputStream(input.getFileDescriptor()); |
| long messageId = Long.valueOf(uri.getLastPathSegment()); |
| long accountId = Long.valueOf(getAccountId(uri)); |
| UpdateMimeMessageFromStream(fIn, accountId, messageId); |
| } catch (IOException e) { |
| Log.w(TAG, "IOException: ", e); |
| /* TODO: How to signal the error to the calling entity? Had expected |
| readDataFromPipe |
| * to throw IOException? |
| */ |
| } finally { |
| try { |
| if (fIn != null) { |
| fIn.close(); |
| } |
| } catch (IOException e) { |
| Log.w(TAG, e); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Read a MIME encoded RFC-2822 fileStream and update the message content. |
| * The Date and/or From headers may not be present in the MIME encoded |
| * message, and this function shall add appropriate values if the headers |
| * are missing. From should be set to the owner of the account. |
| * |
| * @param input the file stream to read data from |
| * @param accountId the accountId |
| * @param messageId ID of the message to update |
| */ |
| protected abstract void UpdateMimeMessageFromStream(FileInputStream input, long accountId, |
| long messageId) throws IOException; |
| |
| public class PipeWriter implements PipeDataWriter<Cursor> { |
| /** |
| * Generate a message based on the cursor, and write the encoded data to the stream. |
| */ |
| |
| @Override |
| public void writeDataToPipe(ParcelFileDescriptor output, Uri uri, String mimeType, |
| Bundle opts, Cursor c) { |
| if (D) { |
| Log.d(TAG, "writeDataToPipe(): uri=" + uri.toString() + " - getLastPathSegment() = " |
| + uri.getLastPathSegment()); |
| } |
| |
| FileOutputStream fout = null; |
| |
| try { |
| fout = new FileOutputStream(output.getFileDescriptor()); |
| |
| boolean includeAttachments = true; |
| boolean download = false; |
| List<String> segments = uri.getPathSegments(); |
| long messageId = Long.parseLong(segments.get(2)); |
| long accountId = Long.parseLong(getAccountId(uri)); |
| if (segments.size() >= 4) { |
| String format = segments.get(3); |
| if (format.equalsIgnoreCase(BluetoothMapContract.FILE_MSG_NO_ATTACHMENTS)) { |
| includeAttachments = false; |
| } else if (format.equalsIgnoreCase( |
| BluetoothMapContract.FILE_MSG_DOWNLOAD_NO_ATTACHMENTS)) { |
| includeAttachments = false; |
| download = true; |
| } else if (format.equalsIgnoreCase(BluetoothMapContract.FILE_MSG_DOWNLOAD)) { |
| download = true; |
| } |
| } |
| |
| WriteMessageToStream(accountId, messageId, includeAttachments, download, fout); |
| } catch (IOException e) { |
| Log.w(TAG, e); |
| /* TODO: How to signal the error to the calling entity? Had expected writeDataToPipe |
| * to throw IOException? |
| */ |
| } finally { |
| try { |
| fout.flush(); |
| } catch (IOException e) { |
| Log.w(TAG, "IOException: ", e); |
| } |
| try { |
| fout.close(); |
| } catch (IOException e) { |
| Log.w(TAG, "IOException: ", e); |
| } |
| } |
| } |
| } |
| |
| /** |
| * This function shall be called when any Account database content have changed |
| * to Notify any attached observers. |
| * @param accountId the ID of the account that changed. Null is a valid value, |
| * if accountId is unknown or multiple accounts changed. |
| */ |
| protected void onAccountChanged(String accountId) { |
| Uri newUri = null; |
| |
| if (mAuthority == null) { |
| return; |
| } |
| if (accountId == null) { |
| newUri = BluetoothMapContract.buildAccountUri(mAuthority); |
| } else { |
| newUri = BluetoothMapContract.buildAccountUriwithId(mAuthority, accountId); |
| } |
| if (D) { |
| Log.d(TAG, "onAccountChanged() accountId = " + accountId + " URI: " + newUri); |
| } |
| mResolver.notifyChange(newUri, null); |
| } |
| |
| /** |
| * This function shall be called when any Message database content have changed |
| * to notify any attached observers. |
| * @param accountId Null is a valid value, if accountId is unknown, but |
| * recommended for increased performance. |
| * @param messageId Null is a valid value, if multiple messages changed or the |
| * messageId is unknown, but recommended for increased performance. |
| */ |
| protected void onMessageChanged(String accountId, String messageId) { |
| Uri newUri = null; |
| |
| if (mAuthority == null) { |
| return; |
| } |
| |
| if (accountId == null) { |
| newUri = BluetoothMapContract.buildMessageUri(mAuthority); |
| } else { |
| if (messageId == null) { |
| newUri = BluetoothMapContract.buildMessageUri(mAuthority, accountId); |
| } else { |
| newUri = BluetoothMapContract.buildMessageUriWithId(mAuthority, accountId, |
| messageId); |
| } |
| } |
| if (D) { |
| Log.d(TAG, "onMessageChanged() accountId = " + accountId + " messageId = " + messageId |
| + " URI: " + newUri); |
| } |
| mResolver.notifyChange(newUri, null); |
| } |
| |
| /** |
| * Not used, this is just a dummy implementation. |
| */ |
| @Override |
| public String getType(Uri uri) { |
| return "Email"; |
| } |
| |
| /** |
| * Open a file descriptor to a message. |
| * Two modes supported for read: With and without attachments. |
| * One mode exist for write and the actual content will be with or without |
| * attachments. |
| * |
| * Mode will be "r" or "w". |
| * |
| * URI format: |
| * The URI scheme is as follows. |
| * For messages with attachments: |
| * content://com.android.mail.bluetoothprovider/Messages/msgId# |
| * |
| * For messages without attachments: |
| * content://com.android.mail.bluetoothprovider/Messages/msgId#/NO_ATTACHMENTS |
| * |
| * UPDATE: For write. |
| * First create a message in the DB using insert into the message DB |
| * Then open a file handle to the #id |
| * write the data to a stream created from the fileHandle. |
| * |
| * @param uri the URI to open. ../Messages/#id |
| * @param mode the mode to use. The following modes exist: - UPDATE do not work - use URI |
| * - "read_with_attachments" - to read an e-mail including any attachments |
| * - "read_no_attachments" - to read an e-mail excluding any attachments |
| * - "write" - to add a mime encoded message to the database. This write |
| * should not trigger the message to be send. |
| * @return the ParcelFileDescriptor |
| * @throws FileNotFoundException |
| */ |
| @Override |
| public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException { |
| long callingId = Binder.clearCallingIdentity(); |
| if (D) { |
| Log.d(TAG, "openFile(): uri=" + uri.toString() + " - getLastPathSegment() = " |
| + uri.getLastPathSegment()); |
| } |
| try { |
| /* To be able to do abstraction of the file IO, we simply ignore the URI at this |
| * point and let the read/write function implementations parse the URI. */ |
| if (mode.equals("w")) { |
| return openInversePipeHelper(uri, null, null, null, mPipeReader); |
| } else { |
| return openPipeHelper(uri, null, null, null, mPipeWriter); |
| } |
| } catch (IOException e) { |
| Log.w(TAG, e); |
| } finally { |
| Binder.restoreCallingIdentity(callingId); |
| } |
| return null; |
| } |
| |
| /** |
| * A helper function for implementing {@link #openFile}, for |
| * creating a data pipe and background thread allowing you to stream |
| * data back from the client. This function returns a new |
| * ParcelFileDescriptor that should be returned to the caller (the caller |
| * is responsible for closing it). |
| * |
| * @param uri The URI whose data is to be written. |
| * @param mimeType The desired type of data to be written. |
| * @param opts Options supplied by caller. |
| * @param args Your own custom arguments. |
| * @param func Interface implementing the function that will actually |
| * stream the data. |
| * @return Returns a new ParcelFileDescriptor holding the read side of |
| * the pipe. This should be returned to the caller for reading; the caller |
| * is responsible for closing it when done. |
| */ |
| private <T> ParcelFileDescriptor openInversePipeHelper(final Uri uri, final String mimeType, |
| final Bundle opts, final T args, final PipeDataReader<T> func) |
| throws FileNotFoundException { |
| try { |
| final ParcelFileDescriptor[] fds = ParcelFileDescriptor.createPipe(); |
| |
| AsyncTask<Object, Object, Object> task = new AsyncTask<Object, Object, Object>() { |
| @Override |
| protected Object doInBackground(Object... params) { |
| func.readDataFromPipe(fds[0], uri, mimeType, opts, args); |
| try { |
| fds[0].close(); |
| } catch (IOException e) { |
| Log.w(TAG, "Failure closing pipe", e); |
| } |
| return null; |
| } |
| }; |
| task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Object[]) null); |
| |
| return fds[1]; |
| } catch (IOException e) { |
| throw new FileNotFoundException("failure making pipe"); |
| } |
| } |
| |
| /** |
| * The MAP specification states that a delete request from MAP client is a folder shift to the |
| * 'deleted' folder. |
| * Only use case of delete() is when transparency is requested for push messages, then |
| * message should not remain in sent folder and therefore must be deleted |
| */ |
| @Override |
| public int delete(Uri uri, String where, String[] selectionArgs) { |
| if (D) { |
| Log.d(TAG, "delete(): uri=" + uri.toString()); |
| } |
| int result = 0; |
| |
| String table = uri.getPathSegments().get(1); |
| if (table == null) { |
| throw new IllegalArgumentException("Table missing in URI"); |
| } |
| // the id of the entry to be deleted from the database |
| String messageId = uri.getLastPathSegment(); |
| if (messageId == null) { |
| throw new IllegalArgumentException("Message ID missing in update values!"); |
| } |
| |
| |
| String accountId = getAccountId(uri); |
| if (accountId == null) { |
| throw new IllegalArgumentException("Account ID missing in update values!"); |
| } |
| |
| long callingId = Binder.clearCallingIdentity(); |
| try { |
| if (table.equals(BluetoothMapContract.TABLE_MESSAGE)) { |
| return deleteMessage(accountId, messageId); |
| } else { |
| if (D) { |
| Log.w(TAG, "Unknown table name: " + table); |
| } |
| return result; |
| } |
| } finally { |
| Binder.restoreCallingIdentity(callingId); |
| } |
| } |
| |
| /** |
| * This function deletes a message. |
| * @param accountId the ID of the Account |
| * @param messageId the ID of the message to delete. |
| * @return the number of messages deleted - 0 if the message was not found. |
| */ |
| protected abstract int deleteMessage(String accountId, String messageId); |
| |
| /** |
| * Insert is used to add new messages to the data base. |
| * Insert message approach: |
| * - Insert an empty message to get an _id with only a folder_id |
| * - Open the _id for write |
| * - Write the message content |
| * (When the writer completes, this provider should do an update of the message) |
| */ |
| @Override |
| public Uri insert(Uri uri, ContentValues values) { |
| String table = uri.getLastPathSegment(); |
| if (table == null) { |
| throw new IllegalArgumentException("Table missing in URI"); |
| } |
| String accountId = getAccountId(uri); |
| Long folderId = values.getAsLong(BluetoothMapContract.MessageColumns.FOLDER_ID); |
| if (folderId == null) { |
| throw new IllegalArgumentException("FolderId missing in ContentValues"); |
| } |
| |
| String id; // the id of the entry inserted into the database |
| long callingId = Binder.clearCallingIdentity(); |
| Log.d(TAG, "insert(): uri=" + uri.toString() + " - getLastPathSegment() = " |
| + uri.getLastPathSegment()); |
| try { |
| if (table.equals(BluetoothMapContract.TABLE_MESSAGE)) { |
| id = insertMessage(accountId, folderId.toString()); |
| if (D) { |
| Log.i(TAG, "insert() ID: " + id); |
| } |
| return Uri.parse(uri.toString() + "/" + id); |
| } else { |
| Log.w(TAG, "Unknown table name: " + table); |
| return null; |
| } |
| } finally { |
| Binder.restoreCallingIdentity(callingId); |
| } |
| } |
| |
| |
| /** |
| * Inserts an empty message into the Message data base in the specified folder. |
| * This is done before the actual message content is written by fileIO. |
| * @param accountId the ID of the account |
| * @param folderId the ID of the folder to create a new message in. |
| * @return the message id as a string |
| */ |
| protected abstract String insertMessage(String accountId, String folderId); |
| |
| /** |
| * Utility function to build a projection based on a projectionMap. |
| * |
| * "btColumnName" -> "emailColumnName as btColumnName" for each entry. |
| * |
| * This supports SQL statements in the emailColumnName entry. |
| * @param projection |
| * @param projectionMap <btColumnName, emailColumnName> |
| * @return the converted projection |
| */ |
| protected String[] convertProjection(String[] projection, Map<String, String> projectionMap) { |
| String[] newProjection = new String[projection.length]; |
| for (int i = 0; i < projection.length; i++) { |
| newProjection[i] = projectionMap.get(projection[i]) + " as " + projection[i]; |
| } |
| return newProjection; |
| } |
| |
| /** |
| * This query needs to map from the data used in the e-mail client to BluetoothMapContract |
| * type of data. |
| */ |
| @Override |
| public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, |
| String sortOrder) { |
| long callingId = Binder.clearCallingIdentity(); |
| try { |
| String accountId = null; |
| switch (mMatcher.match(uri)) { |
| case MATCH_ACCOUNT: |
| return queryAccount(projection, selection, selectionArgs, sortOrder); |
| case MATCH_FOLDER: |
| accountId = getAccountId(uri); |
| return queryFolder(accountId, projection, selection, selectionArgs, sortOrder); |
| case MATCH_MESSAGE: |
| accountId = getAccountId(uri); |
| return queryMessage(accountId, projection, selection, selectionArgs, sortOrder); |
| default: |
| throw new UnsupportedOperationException("Unsupported Uri " + uri); |
| } |
| } finally { |
| Binder.restoreCallingIdentity(callingId); |
| } |
| } |
| |
| /** |
| * Query account information. |
| * This function shall return only exposable e-mail accounts. Hence shall not |
| * return accounts that has policies suggesting not to be shared them. |
| * @param projection |
| * @param selection |
| * @param selectionArgs |
| * @param sortOrder |
| * @return a cursor to the accounts that are subject to exposure over BT. |
| */ |
| protected abstract Cursor queryAccount(String[] projection, String selection, |
| String[] selectionArgs, String sortOrder); |
| |
| /** |
| * Filter out the non usable folders and ensure to name the mandatory folders |
| * inbox, outbox, sent, deleted and draft. |
| * @param accountId |
| * @param projection |
| * @param selection |
| * @param selectionArgs |
| * @param sortOrder |
| * @return |
| */ |
| protected abstract Cursor queryFolder(String accountId, String[] projection, String selection, |
| String[] selectionArgs, String sortOrder); |
| |
| /** |
| * For the message table the selection (where clause) can only include the following columns: |
| * date: less than, greater than and equals |
| * flagRead: = 1 or = 0 |
| * flagPriority: = 1 or = 0 |
| * folder_id: the ID of the folder only equals |
| * toList: partial name/address search |
| * ccList: partial name/address search |
| * bccList: partial name/address search |
| * fromList: partial name/address search |
| * Additionally the COUNT and OFFSET shall be supported. |
| * @param accountId the ID of the account |
| * @param projection |
| * @param selection |
| * @param selectionArgs |
| * @param sortOrder |
| * @return a cursor to query result |
| */ |
| protected abstract Cursor queryMessage(String accountId, String[] projection, String selection, |
| String[] selectionArgs, String sortOrder); |
| |
| /** |
| * update() |
| * Messages can be modified in the following cases: |
| * - the folder_key of a message - hence the message can be moved to a new folder, |
| * but the content cannot be modified. |
| * - the FLAG_READ state can be changed. |
| * The selection statement will always be selection of a message ID, when updating a message, |
| * hence this function will be called multiple times if multiple messages must be updated |
| * due to the nature of the Bluetooth Message Access profile. |
| */ |
| @Override |
| public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { |
| |
| String table = uri.getLastPathSegment(); |
| if (table == null) { |
| throw new IllegalArgumentException("Table missing in URI"); |
| } |
| if (selection != null) { |
| throw new IllegalArgumentException( |
| "selection shall not be used, ContentValues shall contain the data"); |
| } |
| |
| long callingId = Binder.clearCallingIdentity(); |
| if (D) { |
| Log.w(TAG, "update(): uri=" + uri.toString() + " - getLastPathSegment() = " |
| + uri.getLastPathSegment()); |
| } |
| try { |
| if (table.equals(BluetoothMapContract.TABLE_ACCOUNT)) { |
| String accountId = values.getAsString(BluetoothMapContract.AccountColumns._ID); |
| if (accountId == null) { |
| throw new IllegalArgumentException("Account ID missing in update values!"); |
| } |
| Integer exposeFlag = |
| values.getAsInteger(BluetoothMapContract.AccountColumns.FLAG_EXPOSE); |
| if (exposeFlag == null) { |
| throw new IllegalArgumentException("Expose flag missing in update values!"); |
| } |
| return updateAccount(accountId, exposeFlag); |
| } else if (table.equals(BluetoothMapContract.TABLE_FOLDER)) { |
| return 0; // We do not support changing folders |
| } else if (table.equals(BluetoothMapContract.TABLE_MESSAGE)) { |
| String accountId = getAccountId(uri); |
| Long messageId = values.getAsLong(BluetoothMapContract.MessageColumns._ID); |
| if (messageId == null) { |
| throw new IllegalArgumentException("Message ID missing in update values!"); |
| } |
| Long folderId = values.getAsLong(BluetoothMapContract.MessageColumns.FOLDER_ID); |
| Boolean flagRead = |
| values.getAsBoolean(BluetoothMapContract.MessageColumns.FLAG_READ); |
| return updateMessage(accountId, messageId, folderId, flagRead); |
| } else { |
| if (D) { |
| Log.w(TAG, "Unknown table name: " + table); |
| } |
| return 0; |
| } |
| } finally { |
| Binder.restoreCallingIdentity(callingId); |
| } |
| } |
| |
| /** |
| * Update an entry in the account table. Only the expose flag will be |
| * changed through this interface. |
| * @param accountId the ID of the account to change. |
| * @param flagExpose the updated value. |
| * @return the number of entries changed - 0 if account not found or value cannot be changed. |
| */ |
| protected abstract int updateAccount(String accountId, int flagExpose); |
| |
| /** |
| * Update an entry in the message table. |
| * @param accountId ID of the account to which the messageId relates |
| * @param messageId the ID of the message to update |
| * @param folderId the new folder ID value to set - ignore if null. |
| * @param flagRead the new flagRead value to set - ignore if null. |
| * @return |
| */ |
| protected abstract int updateMessage(String accountId, Long messageId, Long folderId, |
| Boolean flagRead); |
| |
| |
| @Override |
| public Bundle call(String method, String arg, Bundle extras) { |
| long callingId = Binder.clearCallingIdentity(); |
| if (D) { |
| Log.d(TAG, "call(): method=" + method + " arg=" + arg + "ThreadId: " |
| + Thread.currentThread().getId()); |
| } |
| |
| try { |
| if (method.equals(BluetoothMapContract.METHOD_UPDATE_FOLDER)) { |
| long accountId = extras.getLong(BluetoothMapContract.EXTRA_UPDATE_ACCOUNT_ID, -1); |
| if (accountId == -1) { |
| Log.w(TAG, "No account ID in CALL"); |
| return null; |
| } |
| long folderId = extras.getLong(BluetoothMapContract.EXTRA_UPDATE_FOLDER_ID, -1); |
| if (folderId == -1) { |
| Log.w(TAG, "No folder ID in CALL"); |
| return null; |
| } |
| int ret = syncFolder(accountId, folderId); |
| if (ret == 0) { |
| return new Bundle(); |
| } |
| return null; |
| } |
| } finally { |
| Binder.restoreCallingIdentity(callingId); |
| } |
| return null; |
| } |
| |
| /** |
| * Trigger a sync of the specified folder. |
| * @param accountId the ID of the account that owns the folder |
| * @param folderId the ID of the folder. |
| * @return 0 at success |
| */ |
| protected abstract int syncFolder(long accountId, long folderId); |
| |
| /** |
| * Need this to suppress warning in unit tests. |
| */ |
| @Override |
| public void shutdown() { |
| // Don't call super.shutdown(), which emits a warning... |
| } |
| |
| /** |
| * Extract the BluetoothMapContract.AccountColumns._ID from the given URI. |
| */ |
| public static String getAccountId(Uri uri) { |
| final List<String> segments = uri.getPathSegments(); |
| if (segments.size() < 1) { |
| throw new IllegalArgumentException("No AccountId pressent in URI: " + uri); |
| } |
| return segments.get(0); |
| } |
| } |
