xref: /packages/apps/Bluetooth/lib/mapapi/com/android/bluetooth/mapapi/BluetoothMapIMProvider.java

/*
* Copyright (C) 2015 Samsung System LSI
* 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.Binder;
import android.os.Bundle;
import android.util.Log;

import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * A base implementation of the BluetoothMapContract.
 * A base class for a ContentProvider that allows access to Instant messages from a Bluetooth
 * device through the Message Access Profile.
 */
public abstract class BluetoothMapIMProvider extends ContentProvider {

    private static final String TAG = "BluetoothMapIMProvider";
    private static final boolean D = true;

    private static final int MATCH_ACCOUNT = 1;
    private static final int MATCH_MESSAGE = 3;
    private static final int MATCH_CONVERSATION = 4;
    private static final int MATCH_CONVOCONTACT = 5;

    protected ContentResolver mResolver;

    private Uri CONTENT_URI = null;
    private String mAuthority;
    private UriMatcher mMatcher;

    /**
     * @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_MESSAGE, MATCH_MESSAGE);
        mMatcher.addURI(mAuthority, "#/" + BluetoothMapContract.TABLE_CONVERSATION,
                MATCH_CONVERSATION);
        mMatcher.addURI(mAuthority, "#/" + BluetoothMapContract.TABLE_CONVOCONTACT,
                MATCH_CONVOCONTACT);

        // 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);
        }
        if (D) {
            Log.d(TAG, "attachInfo() mAuthority = " + mAuthority);
        }

        mResolver = context.getContentResolver();
        super.attachInfo(context, info);
    }

    /**
     * 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);
    }


    /**
     * 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 contactId Null is a valid value, if multiple contacts changed or the
     *        contactId is unknown, but recommended for increased performance.
     */
    protected void onContactChanged(String accountId, String contactId) {
        Uri newUri = null;

        if (mAuthority == null) {
            return;
        }
        if (accountId == null) {
            newUri = BluetoothMapContract.buildConvoContactsUri(mAuthority);
        } else {
            if (contactId == null) {
                newUri = BluetoothMapContract.buildConvoContactsUri(mAuthority, accountId);
            } else {
                newUri = BluetoothMapContract.buildConvoContactsUriWithId(mAuthority, accountId,
                        contactId);
            }
        }
        if (D) {
            Log.d(TAG, "onContactChanged() accountId = " + accountId + " contactId = " + contactId
                    + " URI: " + newUri);
        }
        mResolver.notifyChange(newUri, null);
    }

    /**
     * Not used, this is just a dummy implementation.
     * TODO: We might need to something intelligent here after introducing IM
     */
    @Override
    public String getType(Uri uri) {
        return "InstantMessage";
    }

    /**
     * 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);
        if (accountId == null) {
            throw new IllegalArgumentException("Account ID missing in URI");
        }

        // TODO: validate values?

        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, values);
                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, ContentValues values);

    /**
     * Utility function to build a projection based on a projectionMap.
     *
     *   "btColumnName" -> "imColumnName as btColumnName" for each entry.
     *
     * This supports SQL statements in the column name entry.
     * @param projection
     * @param projectionMap <string, string>
     * @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;
            if (D) {
                Log.w(TAG, "query(): uri =" + mAuthority + " uri=" + uri.toString());
            }

            switch (mMatcher.match(uri)) {
                case MATCH_ACCOUNT:
                    return queryAccount(projection, selection, selectionArgs, sortOrder);
                case MATCH_MESSAGE:
                    // TODO: Extract account from URI
                    accountId = getAccountId(uri);
                    return queryMessage(accountId, projection, selection, selectionArgs, sortOrder);
                case MATCH_CONVERSATION:
                    accountId = getAccountId(uri);
                    String value;
                    String searchString =
                            uri.getQueryParameter(BluetoothMapContract.FILTER_ORIGINATOR_SUBSTRING);
                    Long periodBegin = null;
                    value = uri.getQueryParameter(BluetoothMapContract.FILTER_PERIOD_BEGIN);
                    if (value != null) {
                        periodBegin = Long.parseLong(value);
                    }
                    Long periodEnd = null;
                    value = uri.getQueryParameter(BluetoothMapContract.FILTER_PERIOD_END);
                    if (value != null) {
                        periodEnd = Long.parseLong(value);
                    }
                    Boolean read = null;
                    value = uri.getQueryParameter(BluetoothMapContract.FILTER_READ_STATUS);
                    if (value != null) {
                        read = value.equalsIgnoreCase("true");
                    }
                    Long threadId = null;
                    value = uri.getQueryParameter(BluetoothMapContract.FILTER_THREAD_ID);
                    if (value != null) {
                        threadId = Long.parseLong(value);
                    }
                    return queryConversation(accountId, threadId, read, periodEnd, periodBegin,
                            searchString, projection, sortOrder);
                case MATCH_CONVOCONTACT:
                    accountId = getAccountId(uri);
                    long contactId = 0;
                    return queryConvoContact(accountId, contactId, 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);

    /**
     * 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
     *    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);

    /**
     * For the Conversation table the selection (where clause) can only include
     * the following columns:
     *    _id: the ID of the conversation only equals
     *    name: partial name search
     *    last_activity: less than, greater than and equals
     *    version_counter: updated IDs are regenerated
     * Additionally the COUNT and OFFSET shall be supported.
     * @param accountId the ID of the account
     * @param threadId the ID of the conversation
     * @param projection
     * @param selection
     * @param selectionArgs
     * @param sortOrder
     * @return a cursor to query result
     */
//    abstract protected Cursor queryConversation(Long threadId, String[] projection,
//    String selection, String[] selectionArgs, String sortOrder);

    /**
     * Query for conversations with contact information. The expected result is a cursor pointing
     * to one row for each contact in a conversation.
     * E.g.:
     * ThreadId | ThreadName | ... | ContactName | ContactPrecence | ... |
     *        1 |  "Bowling" | ... |        Hans |               1 | ... |
     *        1 |  "Bowling" | ... |       Peter |               2 | ... |
     *        2 |         "" | ... |       Peter |               2 | ... |
     *        3 |         "" | ... |        Hans |               1 | ... |
     *
     * @param accountId the ID of the account
     * @param threadId filter on a single threadId - null if no filtering is needed.
     * @param read filter on a read status:
     *             null: no filtering on read is needed.
     *             true: return only threads that has NO unread messages.
     *             false: return only threads that has unread messages.
     * @param periodEnd   last_activity time stamp of the the newest thread to include in the
     *                    result.
     * @param periodBegin last_activity time stamp of the the oldest thread to include in the
     *                    result.
     * @param searchString if not null, include only threads that has contacts that matches the
     *                     searchString as part of the contact name or nickName.
     * @param projection A list of the columns that is needed in the result
     * @param sortOrder  the sort order
     * @return a Cursor representing the query result.
     */
    protected abstract Cursor queryConversation(String accountId, Long threadId, Boolean read,
            Long periodEnd, Long periodBegin, String searchString, String[] projection,
            String sortOrder);

    /**
     * For the ConvoContact table the selection (where clause) can only include the
     * following columns:
     *    _id: the ID of the contact only equals
     *    convo_id: id of conversation contact is part of
     *    name: partial name search
     *    x_bt_uid: the ID of the bt uid only equals
     *    chat_state: active, inactive, gone, composing, paused
     *    last_active: less than, greater than and equals
     *    presence_state: online, do_not_disturb, away, offline
     *    priority: level of priority 0 - 100
     *    last_online: less than, greater than and equals
     * @param accountId the ID of the account
     * @param contactId the ID of the contact
     * @param projection
     * @param selection
     * @param selectionArgs
     * @param sortOrder
     * @return a cursor to query result
     */
    protected abstract Cursor queryConvoContact(String accountId, Long contactId,
            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.
     * Conversations can be modified in the following cases:
     *  - the read status - changing between read, unread
     *  - the last activity - the time stamp of last message sent of received in the conversation
     * ConvoContacts can be modified in the following cases:
     *  - the chat_state - chat status of the contact in conversation
     *  - the last_active - the time stamp of last action in the conversation
     *  - the presence_state - the time stamp of last time contact online
     *  - the status - the status text of the contact available in a conversation
     *  - the last_online - the time stamp of last time contact online
     * 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);
                if (accountId == null) {
                    throw new IllegalArgumentException("Account ID missing in update values!");
                }
                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 (table.equals(BluetoothMapContract.TABLE_CONVERSATION)) {
                return 0; // We do not support changing conversation
            } else if (table.equals(BluetoothMapContract.TABLE_CONVOCONTACT)) {
                return 0; // We do not support changing contacts
            } 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, Integer 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);

    /**
     * Utility function to Creates a ContentValues object based on a modified valuesSet.
     * To be used after changing the keys and optionally values of a valueSet obtained
     * from a ContentValues object received in update().
     * @param valueSet the values as received in the contentProvider
     * @param keyMap the key map <btKey, emailKey>
     * @return a new ContentValues object with the keys replaced as specified in the
     * keyMap
     */
    protected ContentValues createContentValues(Set<Entry<String, Object>> valueSet,
            Map<String, String> keyMap) {
        ContentValues values = new ContentValues(valueSet.size());
        for (Entry<String, Object> ent : valueSet) {
            String key = keyMap.get(ent.getKey()); // Convert the key name
            Object value = ent.getValue();
            if (value == null) {
                values.putNull(key);
            } else if (ent.getValue() instanceof Boolean) {
                values.put(key, (Boolean) value);
            } else if (ent.getValue() instanceof Byte) {
                values.put(key, (Byte) value);
            } else if (ent.getValue() instanceof byte[]) {
                values.put(key, (byte[]) value);
            } else if (ent.getValue() instanceof Double) {
                values.put(key, (Double) value);
            } else if (ent.getValue() instanceof Float) {
                values.put(key, (Float) value);
            } else if (ent.getValue() instanceof Integer) {
                values.put(key, (Integer) value);
            } else if (ent.getValue() instanceof Long) {
                values.put(key, (Long) value);
            } else if (ent.getValue() instanceof Short) {
                values.put(key, (Short) value);
            } else if (ent.getValue() instanceof String) {
                values.put(key, (String) value);
            } else {
                throw new IllegalArgumentException("Unknown data type in content value");
            }
        }
        return values;
    }

    @Override
    public Bundle call(String method, String arg, Bundle extras) {
        long callingId = Binder.clearCallingIdentity();
        if (D) {
            Log.w(TAG, "call(): method=" + method + " arg=" + arg + "ThreadId: "
                    + Thread.currentThread().getId());
        }
        int ret = -1;
        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;
                }
                ret = syncFolder(accountId, folderId);
            } else if (method.equals(BluetoothMapContract.METHOD_SET_OWNER_STATUS)) {
                int presenceState = extras.getInt(BluetoothMapContract.EXTRA_PRESENCE_STATE);
                String presenceStatus =
                        extras.getString(BluetoothMapContract.EXTRA_PRESENCE_STATUS);
                long lastActive = extras.getLong(BluetoothMapContract.EXTRA_LAST_ACTIVE);
                int chatState = extras.getInt(BluetoothMapContract.EXTRA_CHAT_STATE);
                String convoId = extras.getString(BluetoothMapContract.EXTRA_CONVERSATION_ID);
                ret = setOwnerStatus(presenceState, presenceStatus, lastActive, chatState, convoId);

            } else if (method.equals(BluetoothMapContract.METHOD_SET_BLUETOOTH_STATE)) {
                boolean bluetoothState =
                        extras.getBoolean(BluetoothMapContract.EXTRA_BLUETOOTH_STATE);
                ret = setBluetoothStatus(bluetoothState);
            }
        } finally {
            Binder.restoreCallingIdentity(callingId);
        }
        if (ret == 0) {
            return new Bundle();
        }
        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);

    /**
     * Set the properties that should change presence or chat state of owner
     * e.g. when the owner is active on a BT client device but not on the BT server device
     * where the IM application is installed, it should still be possible to show an active status.
     * @param presenceState should follow the contract specified values
     * @param presenceStatus string the owners current status
     * @param lastActive time stamp of the owners last activity
     * @param chatState should follow the contract specified values
     * @param convoId ID to the conversation to change
     * @return 0 at success
     */
    protected abstract int setOwnerStatus(int presenceState, String presenceStatus, long lastActive,
            int chatState, String convoId);

    /**
     * Notify the application of the Bluetooth state
     * @param bluetoothState 'on' of 'off'
     * @return 0 at success
     */
    protected abstract int setBluetoothStatus(boolean bluetoothState);


    /**
     * 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);
    }
}