diff options
Diffstat (limited to 'src/android/bluetooth/client/pbap/BluetoothPbapClient.java')
| -rw-r--r-- | src/android/bluetooth/client/pbap/BluetoothPbapClient.java | 846 |
1 files changed, 846 insertions, 0 deletions
diff --git a/src/android/bluetooth/client/pbap/BluetoothPbapClient.java b/src/android/bluetooth/client/pbap/BluetoothPbapClient.java new file mode 100644 index 0000000..5e212e8 --- /dev/null +++ b/src/android/bluetooth/client/pbap/BluetoothPbapClient.java @@ -0,0 +1,846 @@ +/* + * 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); + } +} |