| /* |
| * Copyright (C) 2014 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 android.bluetooth.client.pbap; |
| |
| import android.bluetooth.BluetoothDevice; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.util.Log; |
| |
| import java.lang.ref.WeakReference; |
| |
| /** |
| * Public API to control Phone Book Profile (PCE role only). |
| * <p> |
| * This class defines methods that shall be used by application for the |
| * retrieval of phone book objects from remote device. |
| * <p> |
| * How to connect to remote device which is acting in PSE role: |
| * <ul> |
| * <li>Create a <code>BluetoothDevice</code> object which corresponds to remote |
| * device in PSE role; |
| * <li>Create an instance of <code>BluetoothPbapClient</code> class, passing |
| * <code>BluetothDevice</code> object along with a <code>Handler</code> to it; |
| * <li>Use {@link #setPhoneBookFolderRoot}, {@link #setPhoneBookFolderUp} and |
| * {@link #setPhoneBookFolderDown} to navigate in virtual phone book folder |
| * structure |
| * <li>Use {@link #pullPhoneBookSize} or {@link #pullVcardListingSize} to |
| * retrieve the size of selected phone book |
| * <li>Use {@link #pullPhoneBook} to retrieve phone book entries |
| * <li>Use {@link #pullVcardListing} to retrieve list of entries in the phone |
| * book |
| * <li>Use {@link #pullVcardEntry} to pull single entry from the phone book |
| * </ul> |
| * Upon completion of each call above PCE will notify application if operation |
| * completed successfully (along with results) or failed. |
| * <p> |
| * Therefore, application should handle following events in its message queue |
| * handler: |
| * <ul> |
| * <li><code>EVENT_PULL_PHONE_BOOK_SIZE_DONE</code> |
| * <li><code>EVENT_PULL_VCARD_LISTING_SIZE_DONE</code> |
| * <li><code>EVENT_PULL_PHONE_BOOK_DONE</code> |
| * <li><code>EVENT_PULL_VCARD_LISTING_DONE</code> |
| * <li><code>EVENT_PULL_VCARD_ENTRY_DONE</code> |
| * <li><code>EVENT_SET_PHONE_BOOK_DONE</code> |
| * </ul> |
| * and |
| * <ul> |
| * <li><code>EVENT_PULL_PHONE_BOOK_SIZE_ERROR</code> |
| * <li><code>EVENT_PULL_VCARD_LISTING_SIZE_ERROR</code> |
| * <li><code>EVENT_PULL_PHONE_BOOK_ERROR</code> |
| * <li><code>EVENT_PULL_VCARD_LISTING_ERROR</code> |
| * <li><code>EVENT_PULL_VCARD_ENTRY_ERROR</code> |
| * <li><code>EVENT_SET_PHONE_BOOK_ERROR</code> |
| * </ul> |
| * <code>connect</code> and <code>disconnect</code> methods are introduced for |
| * testing purposes. An application does not need to use them as the session |
| * connection and disconnection happens automatically internally. |
| */ |
| public class BluetoothPbapClient { |
| private static final String TAG = "BluetoothPbapClient"; |
| |
| /** |
| * Path to local incoming calls history object |
| */ |
| public static final String ICH_PATH = "telecom/ich.vcf"; |
| |
| /** |
| * Path to local outgoing calls history object |
| */ |
| public static final String OCH_PATH = "telecom/och.vcf"; |
| |
| /** |
| * Path to local missed calls history object |
| */ |
| public static final String MCH_PATH = "telecom/mch.vcf"; |
| |
| /** |
| * Path to local combined calls history object |
| */ |
| public static final String CCH_PATH = "telecom/cch.vcf"; |
| |
| /** |
| * Path to local main phone book object |
| */ |
| public static final String PB_PATH = "telecom/pb.vcf"; |
| |
| /** |
| * Path to incoming calls history object stored on the phone's SIM card |
| */ |
| public static final String SIM_ICH_PATH = "SIM1/telecom/ich.vcf"; |
| |
| /** |
| * Path to outgoing calls history object stored on the phone's SIM card |
| */ |
| public static final String SIM_OCH_PATH = "SIM1/telecom/och.vcf"; |
| |
| /** |
| * Path to missed calls history object stored on the phone's SIM card |
| */ |
| public static final String SIM_MCH_PATH = "SIM1/telecom/mch.vcf"; |
| |
| /** |
| * Path to combined calls history object stored on the phone's SIM card |
| */ |
| public static final String SIM_CCH_PATH = "SIM1/telecom/cch.vcf"; |
| |
| /** |
| * Path to main phone book object stored on the phone's SIM card |
| */ |
| public static final String SIM_PB_PATH = "SIM1/telecom/pb.vcf"; |
| |
| /** |
| * Indicates to server that default sorting order shall be used for vCard |
| * listing. |
| */ |
| public static final byte ORDER_BY_DEFAULT = -1; |
| |
| /** |
| * Indicates to server that indexed sorting order shall be used for vCard |
| * listing. |
| */ |
| public static final byte ORDER_BY_INDEXED = 0; |
| |
| /** |
| * Indicates to server that alphabetical sorting order shall be used for the |
| * vCard listing. |
| */ |
| public static final byte ORDER_BY_ALPHABETICAL = 1; |
| |
| /** |
| * Indicates to server that phonetical (based on sound attribute) sorting |
| * order shall be used for the vCard listing. |
| */ |
| public static final byte ORDER_BY_PHONETIC = 2; |
| |
| /** |
| * Indicates to server that Name attribute of vCard shall be used to carry |
| * out the search operation on |
| */ |
| public static final byte SEARCH_ATTR_NAME = 0; |
| |
| /** |
| * Indicates to server that Number attribute of vCard shall be used to carry |
| * out the search operation on |
| */ |
| public static final byte SEARCH_ATTR_NUMBER = 1; |
| |
| /** |
| * Indicates to server that Sound attribute of vCard shall be used to carry |
| * out the search operation |
| */ |
| public static final byte SEARCH_ATTR_SOUND = 2; |
| |
| /** |
| * VCard format version 2.1 |
| */ |
| public static final byte VCARD_TYPE_21 = 0; |
| |
| /** |
| * VCard format version 3.0 |
| */ |
| public static final byte VCARD_TYPE_30 = 1; |
| |
| /* 64-bit mask used to filter out VCard fields */ |
| // TODO: Think of extracting to separate class |
| public static final long VCARD_ATTR_VERSION = 0x000000000000000001; |
| public static final long VCARD_ATTR_FN = 0x000000000000000002; |
| public static final long VCARD_ATTR_N = 0x000000000000000004; |
| public static final long VCARD_ATTR_PHOTO = 0x000000000000000008; |
| public static final long VCARD_ATTR_BDAY = 0x000000000000000010; |
| public static final long VCARD_ATTR_ADDR = 0x000000000000000020; |
| public static final long VCARD_ATTR_LABEL = 0x000000000000000040; |
| public static final long VCARD_ATTR_TEL = 0x000000000000000080; |
| public static final long VCARD_ATTR_EMAIL = 0x000000000000000100; |
| public static final long VCARD_ATTR_MAILER = 0x000000000000000200; |
| public static final long VCARD_ATTR_TZ = 0x000000000000000400; |
| public static final long VCARD_ATTR_GEO = 0x000000000000000800; |
| public static final long VCARD_ATTR_TITLE = 0x000000000000001000; |
| public static final long VCARD_ATTR_ROLE = 0x000000000000002000; |
| public static final long VCARD_ATTR_LOGO = 0x000000000000004000; |
| public static final long VCARD_ATTR_AGENT = 0x000000000000008000; |
| public static final long VCARD_ATTR_ORG = 0x000000000000010000; |
| public static final long VCARD_ATTR_NOTE = 0x000000000000020000; |
| public static final long VCARD_ATTR_REV = 0x000000000000040000; |
| public static final long VCARD_ATTR_SOUND = 0x000000000000080000; |
| public static final long VCARD_ATTR_URL = 0x000000000000100000; |
| public static final long VCARD_ATTR_UID = 0x000000000000200000; |
| public static final long VCARD_ATTR_KEY = 0x000000000000400000; |
| public static final long VCARD_ATTR_NICKNAME = 0x000000000000800000; |
| public static final long VCARD_ATTR_CATEGORIES = 0x000000000001000000; |
| public static final long VCARD_ATTR_PROID = 0x000000000002000000; |
| public static final long VCARD_ATTR_CLASS = 0x000000000004000000; |
| public static final long VCARD_ATTR_SORT_STRING = 0x000000000008000000; |
| public static final long VCARD_ATTR_X_IRMC_CALL_DATETIME = |
| 0x000000000010000000; |
| |
| /** |
| * Maximal number of entries of the phone book that PCE can handle |
| */ |
| public static final short MAX_LIST_COUNT = (short) 0xFFFF; |
| |
| /** |
| * Event propagated upon completion of <code>setPhoneBookFolderRoot</code>, |
| * <code>setPhoneBookFolderUp</code> or <code>setPhoneBookFolderDown</code> |
| * request. |
| * <p> |
| * This event indicates that request completed successfully. |
| * @see #setPhoneBookFolderRoot |
| * @see #setPhoneBookFolderUp |
| * @see #setPhoneBookFolderDown |
| */ |
| public static final int EVENT_SET_PHONE_BOOK_DONE = 1; |
| |
| /** |
| * Event propagated upon completion of <code>pullPhoneBook</code> request. |
| * <p> |
| * This event carry on results of the request. |
| * <p> |
| * The resulting message contains: |
| * <table> |
| * <tr> |
| * <td><code>msg.arg1</code></td> |
| * <td>newMissedCalls parameter (only in case of missed calls history object |
| * request)</td> |
| * </tr> |
| * <tr> |
| * <td><code>msg.obj</code></td> |
| * <td>which is a list of <code>VCardEntry</code> objects</td> |
| * </tr> |
| * </table> |
| * @see #pullPhoneBook |
| */ |
| public static final int EVENT_PULL_PHONE_BOOK_DONE = 2; |
| |
| /** |
| * Event propagated upon completion of <code>pullVcardListing</code> |
| * request. |
| * <p> |
| * This event carry on results of the request. |
| * <p> |
| * The resulting message contains: |
| * <table> |
| * <tr> |
| * <td><code>msg.arg1</code></td> |
| * <td>newMissedCalls parameter (only in case of missed calls history object |
| * request)</td> |
| * </tr> |
| * <tr> |
| * <td><code>msg.obj</code></td> |
| * <td>which is a list of <code>BluetoothPbapCard</code> objects</td> |
| * </tr> |
| * </table> |
| * @see #pullVcardListing |
| */ |
| public static final int EVENT_PULL_VCARD_LISTING_DONE = 3; |
| |
| /** |
| * Event propagated upon completion of <code>pullVcardEntry</code> request. |
| * <p> |
| * This event carry on results of the request. |
| * <p> |
| * The resulting message contains: |
| * <table> |
| * <tr> |
| * <td><code>msg.obj</code></td> |
| * <td>vCard as and object of type <code>VCardEntry</code></td> |
| * </tr> |
| * </table> |
| * @see #pullVcardEntry |
| */ |
| public static final int EVENT_PULL_VCARD_ENTRY_DONE = 4; |
| |
| /** |
| * Event propagated upon completion of <code>pullPhoneBookSize</code> |
| * request. |
| * <p> |
| * This event carry on results of the request. |
| * <p> |
| * The resulting message contains: |
| * <table> |
| * <tr> |
| * <td><code>msg.arg1</code></td> |
| * <td>size of the phone book</td> |
| * </tr> |
| * </table> |
| * @see #pullPhoneBookSize |
| */ |
| public static final int EVENT_PULL_PHONE_BOOK_SIZE_DONE = 5; |
| |
| /** |
| * Event propagated upon completion of <code>pullVcardListingSize</code> |
| * request. |
| * <p> |
| * This event carry on results of the request. |
| * <p> |
| * The resulting message contains: |
| * <table> |
| * <tr> |
| * <td><code>msg.arg1</code></td> |
| * <td>size of the phone book listing</td> |
| * </tr> |
| * </table> |
| * @see #pullVcardListingSize |
| */ |
| public static final int EVENT_PULL_VCARD_LISTING_SIZE_DONE = 6; |
| |
| /** |
| * Event propagated upon completion of <code>setPhoneBookFolderRoot</code>, |
| * <code>setPhoneBookFolderUp</code> or <code>setPhoneBookFolderDown</code> |
| * request. This event indicates an error during operation. |
| */ |
| public static final int EVENT_SET_PHONE_BOOK_ERROR = 101; |
| |
| /** |
| * Event propagated upon completion of <code>pullPhoneBook</code> request. |
| * This event indicates an error during operation. |
| */ |
| public static final int EVENT_PULL_PHONE_BOOK_ERROR = 102; |
| |
| /** |
| * Event propagated upon completion of <code>pullVcardListing</code> |
| * request. This event indicates an error during operation. |
| */ |
| public static final int EVENT_PULL_VCARD_LISTING_ERROR = 103; |
| |
| /** |
| * Event propagated upon completion of <code>pullVcardEntry</code> request. |
| * This event indicates an error during operation. |
| */ |
| public static final int EVENT_PULL_VCARD_ENTRY_ERROR = 104; |
| |
| /** |
| * Event propagated upon completion of <code>pullPhoneBookSize</code> |
| * request. This event indicates an error during operation. |
| */ |
| public static final int EVENT_PULL_PHONE_BOOK_SIZE_ERROR = 105; |
| |
| /** |
| * Event propagated upon completion of <code>pullVcardListingSize</code> |
| * request. This event indicates an error during operation. |
| */ |
| public static final int EVENT_PULL_VCARD_LISTING_SIZE_ERROR = 106; |
| |
| /** |
| * Event propagated when PCE has been connected to PSE |
| */ |
| public static final int EVENT_SESSION_CONNECTED = 201; |
| |
| /** |
| * Event propagated when PCE has been disconnected from PSE |
| */ |
| public static final int EVENT_SESSION_DISCONNECTED = 202; |
| public static final int EVENT_SESSION_AUTH_REQUESTED = 203; |
| public static final int EVENT_SESSION_AUTH_TIMEOUT = 204; |
| |
| public enum ConnectionState { |
| DISCONNECTED, CONNECTING, CONNECTED, DISCONNECTING; |
| } |
| |
| private final Handler mClientHandler; |
| private final BluetoothPbapSession mSession; |
| private ConnectionState mConnectionState = ConnectionState.DISCONNECTED; |
| |
| private SessionHandler mSessionHandler; |
| |
| private static class SessionHandler extends Handler { |
| |
| private final WeakReference<BluetoothPbapClient> mClient; |
| |
| SessionHandler(BluetoothPbapClient client) { |
| mClient = new WeakReference<BluetoothPbapClient>(client); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| Log.d(TAG, "handleMessage: what=" + msg.what); |
| |
| BluetoothPbapClient client = mClient.get(); |
| if (client == null) { |
| return; |
| } |
| |
| switch (msg.what) { |
| case BluetoothPbapSession.REQUEST_FAILED: |
| { |
| BluetoothPbapRequest req = (BluetoothPbapRequest) msg.obj; |
| |
| if (req instanceof BluetoothPbapRequestPullPhoneBookSize) { |
| client.sendToClient(EVENT_PULL_PHONE_BOOK_SIZE_ERROR); |
| } else if (req instanceof BluetoothPbapRequestPullVcardListingSize) { |
| client.sendToClient(EVENT_PULL_VCARD_LISTING_SIZE_ERROR); |
| } else if (req instanceof BluetoothPbapRequestPullPhoneBook) { |
| client.sendToClient(EVENT_PULL_PHONE_BOOK_ERROR); |
| } else if (req instanceof BluetoothPbapRequestPullVcardListing) { |
| client.sendToClient(EVENT_PULL_VCARD_LISTING_ERROR); |
| } else if (req instanceof BluetoothPbapRequestPullVcardEntry) { |
| client.sendToClient(EVENT_PULL_VCARD_ENTRY_ERROR); |
| } else if (req instanceof BluetoothPbapRequestSetPath) { |
| client.sendToClient(EVENT_SET_PHONE_BOOK_ERROR); |
| } |
| |
| break; |
| } |
| |
| case BluetoothPbapSession.REQUEST_COMPLETED: |
| { |
| BluetoothPbapRequest req = (BluetoothPbapRequest) msg.obj; |
| |
| if (req instanceof BluetoothPbapRequestPullPhoneBookSize) { |
| int size = ((BluetoothPbapRequestPullPhoneBookSize) req).getSize(); |
| client.sendToClient(EVENT_PULL_PHONE_BOOK_SIZE_DONE, size); |
| |
| } else if (req instanceof BluetoothPbapRequestPullVcardListingSize) { |
| int size = ((BluetoothPbapRequestPullVcardListingSize) req).getSize(); |
| client.sendToClient(EVENT_PULL_VCARD_LISTING_SIZE_DONE, size); |
| |
| } else if (req instanceof BluetoothPbapRequestPullPhoneBook) { |
| BluetoothPbapRequestPullPhoneBook r = (BluetoothPbapRequestPullPhoneBook) req; |
| client.sendToClient(EVENT_PULL_PHONE_BOOK_DONE, r.getNewMissedCalls(), |
| r.getList()); |
| |
| } else if (req instanceof BluetoothPbapRequestPullVcardListing) { |
| BluetoothPbapRequestPullVcardListing r = (BluetoothPbapRequestPullVcardListing) req; |
| client.sendToClient(EVENT_PULL_VCARD_LISTING_DONE, r.getNewMissedCalls(), |
| r.getList()); |
| |
| } else if (req instanceof BluetoothPbapRequestPullVcardEntry) { |
| BluetoothPbapRequestPullVcardEntry r = (BluetoothPbapRequestPullVcardEntry) req; |
| client.sendToClient(EVENT_PULL_VCARD_ENTRY_DONE, r.getVcard()); |
| |
| } else if (req instanceof BluetoothPbapRequestSetPath) { |
| client.sendToClient(EVENT_SET_PHONE_BOOK_DONE); |
| } |
| |
| break; |
| } |
| |
| case BluetoothPbapSession.AUTH_REQUESTED: |
| client.sendToClient(EVENT_SESSION_AUTH_REQUESTED); |
| break; |
| |
| case BluetoothPbapSession.AUTH_TIMEOUT: |
| client.sendToClient(EVENT_SESSION_AUTH_TIMEOUT); |
| break; |
| |
| /* |
| * app does not need to know when session is connected since |
| * OBEX session is managed inside BluetoothPbapSession |
| * automatically - we add this only so app can visualize PBAP |
| * connection status in case it wants to |
| */ |
| |
| case BluetoothPbapSession.SESSION_CONNECTING: |
| client.mConnectionState = ConnectionState.CONNECTING; |
| break; |
| |
| case BluetoothPbapSession.SESSION_CONNECTED: |
| client.mConnectionState = ConnectionState.CONNECTED; |
| client.sendToClient(EVENT_SESSION_CONNECTED); |
| break; |
| |
| case BluetoothPbapSession.SESSION_DISCONNECTED: |
| client.mConnectionState = ConnectionState.DISCONNECTED; |
| client.sendToClient(EVENT_SESSION_DISCONNECTED); |
| break; |
| } |
| } |
| }; |
| |
| private void sendToClient(int eventId) { |
| sendToClient(eventId, 0, null); |
| } |
| |
| private void sendToClient(int eventId, int param) { |
| sendToClient(eventId, param, null); |
| } |
| |
| private void sendToClient(int eventId, Object param) { |
| sendToClient(eventId, 0, param); |
| } |
| |
| private void sendToClient(int eventId, int param1, Object param2) { |
| mClientHandler.obtainMessage(eventId, param1, 0, param2).sendToTarget(); |
| } |
| |
| /** |
| * Constructs PCE object |
| * |
| * @param device BluetoothDevice that corresponds to remote acting in PSE |
| * role |
| * @param handler the handle that will be used by PCE to notify events and |
| * results to application |
| * @throws NullPointerException |
| */ |
| public BluetoothPbapClient(BluetoothDevice device, Handler handler) { |
| if (device == null) { |
| throw new NullPointerException("BluetothDevice is null"); |
| } |
| |
| mClientHandler = handler; |
| |
| mSessionHandler = new SessionHandler(this); |
| |
| mSession = new BluetoothPbapSession(device, mSessionHandler); |
| } |
| |
| /** |
| * Starts a pbap session. <pb> This method set up rfcomm session, obex |
| * session and waits for requests to be transfered to PSE. |
| */ |
| public void connect() { |
| mSession.start(); |
| } |
| |
| @Override |
| public void finalize() { |
| if (mSession != null) { |
| mSession.stop(); |
| } |
| } |
| |
| /** |
| * Stops all the active transactions and disconnects from the server. |
| */ |
| public void disconnect() { |
| mSession.stop(); |
| } |
| |
| /** |
| * Aborts current request, if any |
| */ |
| public void abort() { |
| mSession.abort(); |
| } |
| |
| public ConnectionState getState() { |
| return mConnectionState; |
| } |
| |
| /** |
| * Sets current folder to root |
| * |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_SET_PHONE_BOOK_DONE} or |
| * {@link #EVENT_SET_PHONE_BOOK_ERROR} in case of failure |
| */ |
| public boolean setPhoneBookFolderRoot() { |
| BluetoothPbapRequest req = new BluetoothPbapRequestSetPath(false); |
| return mSession.makeRequest(req); |
| } |
| |
| /** |
| * Sets current folder to parent |
| * |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_SET_PHONE_BOOK_DONE} or |
| * {@link #EVENT_SET_PHONE_BOOK_ERROR} in case of failure |
| */ |
| public boolean setPhoneBookFolderUp() { |
| BluetoothPbapRequest req = new BluetoothPbapRequestSetPath(true); |
| return mSession.makeRequest(req); |
| } |
| |
| /** |
| * Sets current folder to selected sub-folder |
| * |
| * @param folder the name of the sub-folder |
| * @return @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_SET_PHONE_BOOK_DONE} or |
| * {@link #EVENT_SET_PHONE_BOOK_ERROR} in case of failure |
| */ |
| public boolean setPhoneBookFolderDown(String folder) { |
| BluetoothPbapRequest req = new BluetoothPbapRequestSetPath(folder); |
| return mSession.makeRequest(req); |
| } |
| |
| /** |
| * Requests for the number of entries in the phone book. |
| * |
| * @param pbName absolute path to the phone book |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_PHONE_BOOK_SIZE_DONE} or |
| * {@link #EVENT_PULL_PHONE_BOOK_SIZE_ERROR} in case of failure |
| */ |
| public boolean pullPhoneBookSize(String pbName) { |
| BluetoothPbapRequestPullPhoneBookSize req = new BluetoothPbapRequestPullPhoneBookSize( |
| pbName); |
| |
| return mSession.makeRequest(req); |
| } |
| |
| /** |
| * Requests for the number of entries in the phone book listing. |
| * |
| * @param folder the name of the folder to be retrieved |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_VCARD_LISTING_SIZE_DONE} or |
| * {@link #EVENT_PULL_VCARD_LISTING_SIZE_ERROR} in case of failure |
| */ |
| public boolean pullVcardListingSize(String folder) { |
| BluetoothPbapRequestPullVcardListingSize req = new BluetoothPbapRequestPullVcardListingSize( |
| folder); |
| |
| return mSession.makeRequest(req); |
| } |
| |
| /** |
| * Pulls complete phone book. This method pulls phone book which entries are |
| * of <code>VCARD_TYPE_21</code> type and each single vCard contains minimal |
| * required set of fields and the number of entries in response is not |
| * limited. |
| * |
| * @param pbName absolute path to the phone book |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_PHONE_BOOK_DONE} or |
| * {@link #EVENT_PULL_PHONE_BOOK_ERROR} in case of failure |
| */ |
| public boolean pullPhoneBook(String pbName) { |
| return pullPhoneBook(pbName, 0, VCARD_TYPE_21, 0, 0); |
| } |
| |
| /** |
| * Pulls complete phone book. This method pulls all entries from the phone |
| * book. |
| * |
| * @param pbName absolute path to the phone book |
| * @param filter bit mask which indicates which fields of the vCard shall be |
| * included in each entry of the resulting list |
| * @param format vCard format of entries in the resulting list |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_PHONE_BOOK_DONE} or |
| * {@link #EVENT_PULL_PHONE_BOOK_ERROR} in case of failure |
| */ |
| public boolean pullPhoneBook(String pbName, long filter, byte format) { |
| return pullPhoneBook(pbName, filter, format, 0, 0); |
| } |
| |
| /** |
| * Pulls complete phone book. This method pulls entries from the phone book |
| * limited to the number of <code>maxListCount</code> starting from the |
| * position of <code>listStartOffset</code>. |
| * <p> |
| * The resulting list contains vCard objects in version |
| * <code>VCARD_TYPE_21</code> which in turns contain minimal required set of |
| * vCard fields. |
| * |
| * @param pbName absolute path to the phone book |
| * @param maxListCount limits number of entries in the response |
| * @param listStartOffset offset to the first entry of the list that would |
| * be returned |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_PHONE_BOOK_DONE} or |
| * {@link #EVENT_PULL_PHONE_BOOK_ERROR} in case of failure |
| */ |
| public boolean pullPhoneBook(String pbName, int maxListCount, int listStartOffset) { |
| return pullPhoneBook(pbName, 0, VCARD_TYPE_21, maxListCount, listStartOffset); |
| } |
| |
| /** |
| * Pulls complete phone book. |
| * |
| * @param pbName absolute path to the phone book |
| * @param filter bit mask which indicates which fields of the vCard hall be |
| * included in each entry of the resulting list |
| * @param format vCard format of entries in the resulting list |
| * @param maxListCount limits number of entries in the response |
| * @param listStartOffset offset to the first entry of the list that would |
| * be returned |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_PHONE_BOOK_DONE} or |
| * {@link #EVENT_PULL_PHONE_BOOK_ERROR} in case of failure |
| */ |
| public boolean pullPhoneBook(String pbName, long filter, byte format, int maxListCount, |
| int listStartOffset) { |
| BluetoothPbapRequest req = new BluetoothPbapRequestPullPhoneBook(pbName, filter, format, |
| maxListCount, listStartOffset); |
| return mSession.makeRequest(req); |
| } |
| |
| /** |
| * Pulls list of entries in the phone book. |
| * <p> |
| * This method pulls the list of entries in the <code>folder</code>. |
| * |
| * @param folder the name of the folder to be retrieved |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_VCARD_LISTING_DONE} or |
| * {@link #EVENT_PULL_VCARD_LISTING_ERROR} in case of failure |
| */ |
| public boolean pullVcardListing(String folder) { |
| return pullVcardListing(folder, ORDER_BY_DEFAULT, SEARCH_ATTR_NAME, null, 0, 0); |
| } |
| |
| /** |
| * Pulls list of entries in the <code>folder</code>. |
| * |
| * @param folder the name of the folder to be retrieved |
| * @param order the sorting order of the resulting list of entries |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_VCARD_LISTING_DONE} or |
| * {@link #EVENT_PULL_VCARD_LISTING_ERROR} in case of failure |
| */ |
| public boolean pullVcardListing(String folder, byte order) { |
| return pullVcardListing(folder, order, SEARCH_ATTR_NAME, null, 0, 0); |
| } |
| |
| /** |
| * Pulls list of entries in the <code>folder</code>. Only entries where |
| * <code>searchAttr</code> attribute of vCard matches <code>searchVal</code> |
| * will be listed. |
| * |
| * @param folder the name of the folder to be retrieved |
| * @param searchAttr vCard attribute which shall be used to carry out search |
| * operation on |
| * @param searchVal text string used by matching routine to match the value |
| * of the attribute indicated by SearchAttr |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_VCARD_LISTING_DONE} or |
| * {@link #EVENT_PULL_VCARD_LISTING_ERROR} in case of failure |
| */ |
| public boolean pullVcardListing(String folder, byte searchAttr, String searchVal) { |
| return pullVcardListing(folder, ORDER_BY_DEFAULT, searchAttr, searchVal, 0, 0); |
| } |
| |
| /** |
| * Pulls list of entries in the <code>folder</code>. |
| * |
| * @param folder the name of the folder to be retrieved |
| * @param order the sorting order of the resulting list of entries |
| * @param maxListCount limits number of entries in the response |
| * @param listStartOffset offset to the first entry of the list that would |
| * be returned |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_VCARD_LISTING_DONE} or |
| * {@link #EVENT_PULL_VCARD_LISTING_ERROR} in case of failure |
| */ |
| public boolean pullVcardListing(String folder, byte order, int maxListCount, |
| int listStartOffset) { |
| return pullVcardListing(folder, order, SEARCH_ATTR_NAME, null, maxListCount, |
| listStartOffset); |
| } |
| |
| /** |
| * Pulls list of entries in the <code>folder</code>. |
| * |
| * @param folder the name of the folder to be retrieved |
| * @param maxListCount limits number of entries in the response |
| * @param listStartOffset offset to the first entry of the list that would |
| * be returned |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_VCARD_LISTING_DONE} or |
| * {@link #EVENT_PULL_VCARD_LISTING_ERROR} in case of failure |
| */ |
| public boolean pullVcardListing(String folder, int maxListCount, int listStartOffset) { |
| return pullVcardListing(folder, ORDER_BY_DEFAULT, SEARCH_ATTR_NAME, null, maxListCount, |
| listStartOffset); |
| } |
| |
| /** |
| * Pulls list of entries in the <code>folder</code>. |
| * |
| * @param folder the name of the folder to be retrieved |
| * @param order the sorting order of the resulting list of entries |
| * @param searchAttr vCard attribute which shall be used to carry out search |
| * operation on |
| * @param searchVal text string used by matching routine to match the value |
| * of the attribute indicated by SearchAttr |
| * @param maxListCount limits number of entries in the response |
| * @param listStartOffset offset to the first entry of the list that would |
| * be returned |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_VCARD_LISTING_DONE} or |
| * {@link #EVENT_PULL_VCARD_LISTING_ERROR} in case of failure |
| */ |
| public boolean pullVcardListing(String folder, byte order, byte searchAttr, |
| String searchVal, int maxListCount, int listStartOffset) { |
| BluetoothPbapRequest req = new BluetoothPbapRequestPullVcardListing(folder, order, |
| searchAttr, searchVal, maxListCount, listStartOffset); |
| return mSession.makeRequest(req); |
| } |
| |
| /** |
| * Pulls single vCard object |
| * |
| * @param handle handle to the vCard which shall be pulled |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_VCARD_DONE} or |
| * @link #EVENT_PULL_VCARD_ERROR} in case of failure |
| */ |
| public boolean pullVcardEntry(String handle) { |
| return pullVcardEntry(handle, (byte) 0, VCARD_TYPE_21); |
| } |
| |
| /** |
| * Pulls single vCard object |
| * |
| * @param handle handle to the vCard which shall be pulled |
| * @param filter bit mask of the vCard fields that shall be included in the |
| * resulting vCard |
| * @param format resulting vCard version |
| * @return <code>true</code> if request has been sent successfully; |
| * <code>false</code> otherwise; upon completion PCE sends |
| * {@link #EVENT_PULL_VCARD_DONE} |
| * @link #EVENT_PULL_VCARD_ERROR} in case of failure |
| */ |
| public boolean pullVcardEntry(String handle, long filter, byte format) { |
| BluetoothPbapRequest req = new BluetoothPbapRequestPullVcardEntry(handle, filter, format); |
| return mSession.makeRequest(req); |
| } |
| |
| public boolean setAuthResponse(String key) { |
| Log.d(TAG, " setAuthResponse key=" + key); |
| return mSession.setAuthResponse(key); |
| } |
| } |
