| /* |
| * Copyright (c) 2008-2009, Motorola, Inc. |
| * |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * - Redistributions of source code must retain the above copyright notice, |
| * this list of conditions and the following disclaimer. |
| * |
| * - Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * - Neither the name of the Motorola, Inc. nor the names of its contributors |
| * may be used to endorse or promote products derived from this software |
| * without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| package com.android.bluetooth.pbap; |
| |
| import android.content.Context; |
| import android.os.Message; |
| import android.os.Handler; |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.provider.CallLog.Calls; |
| import android.provider.CallLog; |
| |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| |
| import javax.obex.ServerRequestHandler; |
| import javax.obex.ResponseCodes; |
| import javax.obex.ApplicationParameter; |
| import javax.obex.ServerOperation; |
| import javax.obex.Operation; |
| import javax.obex.HeaderSet; |
| |
| public class BluetoothPbapObexServer extends ServerRequestHandler { |
| |
| private static final String TAG = "BluetoothPbapObexServer"; |
| |
| private static final boolean D = BluetoothPbapService.DEBUG; |
| |
| private static final boolean V = BluetoothPbapService.VERBOSE; |
| |
| private static final int UUID_LENGTH = 16; |
| |
| // The length of suffix of vcard name - ".vcf" is 5 |
| private static final int VCARD_NAME_SUFFIX_LENGTH = 5; |
| |
| // 128 bit UUID for PBAP |
| private static final byte[] PBAP_TARGET = new byte[] { |
| 0x79, 0x61, 0x35, (byte)0xf0, (byte)0xf0, (byte)0xc5, 0x11, (byte)0xd8, 0x09, 0x66, |
| 0x08, 0x00, 0x20, 0x0c, (byte)0x9a, 0x66 |
| }; |
| |
| // Currently not support SIM card |
| private static final String[] LEGAL_PATH = { |
| "/telecom", "/telecom/pb", "/telecom/ich", "/telecom/och", "/telecom/mch", |
| "/telecom/cch" |
| }; |
| |
| @SuppressWarnings("unused") |
| private static final String[] LEGAL_PATH_WITH_SIM = { |
| "/telecom", "/telecom/pb", "/telecom/ich", "/telecom/och", "/telecom/mch", |
| "/telecom/cch", "/SIM1", "/SIM1/telecom", "/SIM1/telecom/ich", "/SIM1/telecom/och", |
| "/SIM1/telecom/mch", "/SIM1/telecom/cch", "/SIM1/telecom/pb" |
| |
| }; |
| |
| // SIM card |
| private static final String SIM1 = "SIM1"; |
| |
| // missed call history |
| private static final String MCH = "mch"; |
| |
| // incoming call history |
| private static final String ICH = "ich"; |
| |
| // outgoing call history |
| private static final String OCH = "och"; |
| |
| // combined call history |
| private static final String CCH = "cch"; |
| |
| // phone book |
| private static final String PB = "pb"; |
| |
| private static final String ICH_PATH = "/telecom/ich"; |
| |
| private static final String OCH_PATH = "/telecom/och"; |
| |
| private static final String MCH_PATH = "/telecom/mch"; |
| |
| private static final String CCH_PATH = "/telecom/cch"; |
| |
| private static final String PB_PATH = "/telecom/pb"; |
| |
| // type for list vcard objects |
| private static final String TYPE_LISTING = "x-bt/vcard-listing"; |
| |
| // type for get single vcard object |
| private static final String TYPE_VCARD = "x-bt/vcard"; |
| |
| // to indicate if need send body besides headers |
| private static final int NEED_SEND_BODY = -1; |
| |
| // type for download all vcard objects |
| private static final String TYPE_PB = "x-bt/phonebook"; |
| |
| // The number of indexes in the phone book. |
| private boolean mNeedPhonebookSize = false; |
| |
| // The number of missed calls that have not been checked on the PSE at the |
| // point of the request. Only apply to "mch" case. |
| private boolean mNeedNewMissedCallsNum = false; |
| |
| private int mMissedCallSize = 0; |
| |
| // record current path the client are browsing |
| private String mCurrentPath = ""; |
| |
| private Handler mCallback = null; |
| |
| private Context mContext; |
| |
| private BluetoothPbapVcardManager mVcardManager; |
| |
| private int mOrderBy = ORDER_BY_INDEXED; |
| |
| private static int CALLLOG_NUM_LIMIT = 50; |
| |
| public static int ORDER_BY_INDEXED = 0; |
| |
| public static int ORDER_BY_ALPHABETICAL = 1; |
| |
| public static boolean sIsAborted = false; |
| |
| public static class ContentType { |
| public static final int PHONEBOOK = 1; |
| |
| public static final int INCOMING_CALL_HISTORY = 2; |
| |
| public static final int OUTGOING_CALL_HISTORY = 3; |
| |
| public static final int MISSED_CALL_HISTORY = 4; |
| |
| public static final int COMBINED_CALL_HISTORY = 5; |
| } |
| |
| public BluetoothPbapObexServer(Handler callback, Context context) { |
| super(); |
| mCallback = callback; |
| mContext = context; |
| mVcardManager = new BluetoothPbapVcardManager(mContext); |
| |
| // set initial value when ObexServer created |
| mMissedCallSize = mVcardManager.getPhonebookSize(ContentType.MISSED_CALL_HISTORY); |
| if (D) Log.d(TAG, "Initialize mMissedCallSize=" + mMissedCallSize); |
| } |
| |
| @Override |
| public int onConnect(final HeaderSet request, HeaderSet reply) { |
| if (V) logHeader(request); |
| try { |
| byte[] uuid = (byte[])request.getHeader(HeaderSet.TARGET); |
| if (uuid == null) { |
| return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE; |
| } |
| if (D) Log.d(TAG, "onConnect(): uuid=" + Arrays.toString(uuid)); |
| |
| if (uuid.length != UUID_LENGTH) { |
| Log.w(TAG, "Wrong UUID length"); |
| return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE; |
| } |
| for (int i = 0; i < UUID_LENGTH; i++) { |
| if (uuid[i] != PBAP_TARGET[i]) { |
| Log.w(TAG, "Wrong UUID"); |
| return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE; |
| } |
| } |
| reply.setHeader(HeaderSet.WHO, uuid); |
| } catch (IOException e) { |
| Log.e(TAG, e.toString()); |
| return ResponseCodes.OBEX_HTTP_INTERNAL_ERROR; |
| } |
| |
| try { |
| byte[] remote = (byte[])request.getHeader(HeaderSet.WHO); |
| if (remote != null) { |
| if (D) Log.d(TAG, "onConnect(): remote=" + Arrays.toString(remote)); |
| reply.setHeader(HeaderSet.TARGET, remote); |
| } |
| } catch (IOException e) { |
| Log.e(TAG, e.toString()); |
| return ResponseCodes.OBEX_HTTP_INTERNAL_ERROR; |
| } |
| |
| if (V) Log.v(TAG, "onConnect(): uuid is ok, will send out " + |
| "MSG_SESSION_ESTABLISHED msg."); |
| |
| Message msg = Message.obtain(mCallback); |
| msg.what = BluetoothPbapService.MSG_SESSION_ESTABLISHED; |
| msg.sendToTarget(); |
| |
| return ResponseCodes.OBEX_HTTP_OK; |
| } |
| |
| @Override |
| public void onDisconnect(final HeaderSet req, final HeaderSet resp) { |
| if (D) Log.d(TAG, "onDisconnect(): enter"); |
| if (V) logHeader(req); |
| |
| resp.responseCode = ResponseCodes.OBEX_HTTP_OK; |
| if (mCallback != null) { |
| Message msg = Message.obtain(mCallback); |
| msg.what = BluetoothPbapService.MSG_SESSION_DISCONNECTED; |
| msg.sendToTarget(); |
| if (V) Log.v(TAG, "onDisconnect(): msg MSG_SESSION_DISCONNECTED sent out."); |
| } |
| } |
| |
| @Override |
| public int onAbort(HeaderSet request, HeaderSet reply) { |
| if (D) Log.d(TAG, "onAbort(): enter."); |
| sIsAborted = true; |
| return ResponseCodes.OBEX_HTTP_OK; |
| } |
| |
| @Override |
| public int onPut(final Operation op) { |
| if (D) Log.d(TAG, "onPut(): not support PUT request."); |
| return ResponseCodes.OBEX_HTTP_BAD_REQUEST; |
| } |
| |
| @Override |
| public int onSetPath(final HeaderSet request, final HeaderSet reply, final boolean backup, |
| final boolean create) { |
| if (V) logHeader(request); |
| if (D) Log.d(TAG, "before setPath, mCurrentPath == " + mCurrentPath); |
| |
| String current_path_tmp = mCurrentPath; |
| String tmp_path = null; |
| try { |
| tmp_path = (String)request.getHeader(HeaderSet.NAME); |
| } catch (IOException e) { |
| Log.e(TAG, "Get name header fail"); |
| return ResponseCodes.OBEX_HTTP_INTERNAL_ERROR; |
| } |
| if (D) Log.d(TAG, "backup=" + backup + " create=" + create + " name=" + tmp_path); |
| |
| if (backup) { |
| if (current_path_tmp.length() != 0) { |
| current_path_tmp = current_path_tmp.substring(0, |
| current_path_tmp.lastIndexOf("/")); |
| } |
| } else { |
| if (tmp_path == null) { |
| current_path_tmp = ""; |
| } else { |
| current_path_tmp = current_path_tmp + "/" + tmp_path; |
| } |
| } |
| |
| if ((current_path_tmp.length() != 0) && (!isLegalPath(current_path_tmp))) { |
| if (create) { |
| Log.w(TAG, "path create is forbidden!"); |
| return ResponseCodes.OBEX_HTTP_FORBIDDEN; |
| } else { |
| Log.w(TAG, "path is not legal"); |
| return ResponseCodes.OBEX_HTTP_NOT_FOUND; |
| } |
| } |
| mCurrentPath = current_path_tmp; |
| if (V) Log.v(TAG, "after setPath, mCurrentPath == " + mCurrentPath); |
| |
| return ResponseCodes.OBEX_HTTP_OK; |
| } |
| |
| @Override |
| public void onClose() { |
| if (mCallback != null) { |
| Message msg = Message.obtain(mCallback); |
| msg.what = BluetoothPbapService.MSG_SERVERSESSION_CLOSE; |
| msg.sendToTarget(); |
| if (D) Log.d(TAG, "onClose(): msg MSG_SERVERSESSION_CLOSE sent out."); |
| } |
| } |
| |
| @Override |
| public int onGet(Operation op) { |
| sIsAborted = false; |
| HeaderSet request = null; |
| HeaderSet reply = new HeaderSet(); |
| String type = ""; |
| String name = ""; |
| byte[] appParam = null; |
| AppParamValue appParamValue = new AppParamValue(); |
| try { |
| request = op.getReceivedHeader(); |
| type = (String)request.getHeader(HeaderSet.TYPE); |
| name = (String)request.getHeader(HeaderSet.NAME); |
| appParam = (byte[])request.getHeader(HeaderSet.APPLICATION_PARAMETER); |
| } catch (IOException e) { |
| Log.e(TAG, "request headers error"); |
| return ResponseCodes.OBEX_HTTP_INTERNAL_ERROR; |
| } |
| |
| if (V) logHeader(request); |
| if (D) Log.d(TAG, "OnGet type is " + type + "; name is " + name); |
| |
| if (type == null) { |
| return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE; |
| } |
| // Accroding to specification,the name header could be omitted such as |
| // sony erriccsonHBH-DS980 |
| |
| // For "x-bt/phonebook" and "x-bt/vcard-listing": |
| // if name == null, guess what carkit actually want from current path |
| // For "x-bt/vcard": |
| // We decide which kind of content client would like per current path |
| |
| boolean validName = true; |
| if (TextUtils.isEmpty(name)) { |
| validName = false; |
| } |
| |
| if (!validName || (validName && type.equals(TYPE_VCARD))) { |
| if (D) Log.d(TAG, "Guess what carkit actually want from current path (" + |
| mCurrentPath + ")"); |
| |
| if (mCurrentPath.equals(PB_PATH)) { |
| appParamValue.needTag = ContentType.PHONEBOOK; |
| } else if (mCurrentPath.equals(ICH_PATH)) { |
| appParamValue.needTag = ContentType.INCOMING_CALL_HISTORY; |
| } else if (mCurrentPath.equals(OCH_PATH)) { |
| appParamValue.needTag = ContentType.OUTGOING_CALL_HISTORY; |
| } else if (mCurrentPath.equals(MCH_PATH)) { |
| appParamValue.needTag = ContentType.MISSED_CALL_HISTORY; |
| mNeedNewMissedCallsNum = true; |
| } else if (mCurrentPath.equals(CCH_PATH)) { |
| appParamValue.needTag = ContentType.COMBINED_CALL_HISTORY; |
| } else { |
| Log.w(TAG, "mCurrentpath is not valid path!!!"); |
| return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE; |
| } |
| if (D) Log.v(TAG, "onGet(): appParamValue.needTag=" + appParamValue.needTag); |
| } else { |
| // Not support SIM card currently |
| if (name.contains(SIM1.subSequence(0, SIM1.length()))) { |
| Log.w(TAG, "Not support access SIM card info!"); |
| return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE; |
| } |
| |
| // we have weak name checking here to provide better |
| // compatibility with other devices,although unique name such as |
| // "pb.vcf" is required by SIG spec. |
| if (name.contains(PB.subSequence(0, PB.length()))) { |
| appParamValue.needTag = ContentType.PHONEBOOK; |
| if (D) Log.v(TAG, "download phonebook request"); |
| } else if (name.contains(ICH.subSequence(0, ICH.length()))) { |
| appParamValue.needTag = ContentType.INCOMING_CALL_HISTORY; |
| if (D) Log.v(TAG, "download incoming calls request"); |
| } else if (name.contains(OCH.subSequence(0, OCH.length()))) { |
| appParamValue.needTag = ContentType.OUTGOING_CALL_HISTORY; |
| if (D) Log.v(TAG, "download outgoing calls request"); |
| } else if (name.contains(MCH.subSequence(0, MCH.length()))) { |
| appParamValue.needTag = ContentType.MISSED_CALL_HISTORY; |
| mNeedNewMissedCallsNum = true; |
| if (D) Log.v(TAG, "download missed calls request"); |
| } else if (name.contains(CCH.subSequence(0, CCH.length()))) { |
| appParamValue.needTag = ContentType.COMBINED_CALL_HISTORY; |
| if (D) Log.v(TAG, "download combined calls request"); |
| } else { |
| Log.w(TAG, "Input name doesn't contain valid info!!!"); |
| return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE; |
| } |
| } |
| |
| if ((appParam != null) && !parseApplicationParameter(appParam, appParamValue)) { |
| return ResponseCodes.OBEX_HTTP_BAD_REQUEST; |
| } |
| |
| // listing request |
| if (type.equals(TYPE_LISTING)) { |
| return pullVcardListing(appParam, appParamValue, reply, op); |
| } |
| // pull vcard entry request |
| else if (type.equals(TYPE_VCARD)) { |
| return pullVcardEntry(appParam, appParamValue, op, name, mCurrentPath); |
| } |
| // down load phone book request |
| else if (type.equals(TYPE_PB)) { |
| return pullPhonebook(appParam, appParamValue, reply, op, name); |
| } else { |
| Log.w(TAG, "unknown type request!!!"); |
| return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE; |
| } |
| } |
| |
| /** check whether path is legal */ |
| private final boolean isLegalPath(final String str) { |
| if (str.length() == 0) { |
| return true; |
| } |
| for (int i = 0; i < LEGAL_PATH.length; i++) { |
| if (str.equals(LEGAL_PATH[i])) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private class AppParamValue { |
| public int maxListCount; |
| |
| public int listStartOffset; |
| |
| public String searchValue; |
| |
| // Indicate which vCard parameter the search operation shall be carried |
| // out on. Can be "Name | Number | Sound", default value is "Name". |
| public String searchAttr; |
| |
| // Indicate which sorting order shall be used for the |
| // <x-bt/vcard-listing> listing object. |
| // Can be "Alphabetical | Indexed | Phonetical", default value is |
| // "Indexed". |
| public String order; |
| |
| public int needTag; |
| |
| public boolean vcard21; |
| |
| public AppParamValue() { |
| maxListCount = 0xFFFF; |
| listStartOffset = 0; |
| searchValue = ""; |
| searchAttr = ""; |
| order = ""; |
| needTag = 0x00; |
| vcard21 = true; |
| } |
| |
| public void dump() { |
| Log.i(TAG, "maxListCount=" + maxListCount + " listStartOffset=" + listStartOffset |
| + " searchValue=" + searchValue + " searchAttr=" + searchAttr + " needTag=" |
| + needTag + " vcard21=" + vcard21 + " order=" + order); |
| } |
| } |
| |
| /** To parse obex application parameter */ |
| private final boolean parseApplicationParameter(final byte[] appParam, |
| AppParamValue appParamValue) { |
| int i = 0; |
| boolean parseOk = true; |
| while (i < appParam.length) { |
| switch (appParam[i]) { |
| case ApplicationParameter.TRIPLET_TAGID.FILTER_TAGID: |
| i += 2; // length and tag field in triplet |
| i += ApplicationParameter.TRIPLET_LENGTH.FILTER_LENGTH; |
| break; |
| case ApplicationParameter.TRIPLET_TAGID.ORDER_TAGID: |
| i += 2; // length and tag field in triplet |
| appParamValue.order = Byte.toString(appParam[i]); |
| i += ApplicationParameter.TRIPLET_LENGTH.ORDER_LENGTH; |
| break; |
| case ApplicationParameter.TRIPLET_TAGID.SEARCH_VALUE_TAGID: |
| i += 1; // length field in triplet |
| // length of search value is variable |
| int length = appParam[i]; |
| if (length == 0) { |
| parseOk = false; |
| break; |
| } |
| if (appParam[i+length] == 0x0) { |
| appParamValue.searchValue = new String(appParam, i + 1, length-1); |
| } else { |
| appParamValue.searchValue = new String(appParam, i + 1, length); |
| } |
| i += length; |
| i += 1; |
| break; |
| case ApplicationParameter.TRIPLET_TAGID.SEARCH_ATTRIBUTE_TAGID: |
| i += 2; |
| appParamValue.searchAttr = Byte.toString(appParam[i]); |
| i += ApplicationParameter.TRIPLET_LENGTH.SEARCH_ATTRIBUTE_LENGTH; |
| break; |
| case ApplicationParameter.TRIPLET_TAGID.MAXLISTCOUNT_TAGID: |
| i += 2; |
| if (appParam[i] == 0 && appParam[i + 1] == 0) { |
| mNeedPhonebookSize = true; |
| } else { |
| int highValue = appParam[i] & 0xff; |
| int lowValue = appParam[i + 1] & 0xff; |
| appParamValue.maxListCount = highValue * 256 + lowValue; |
| } |
| i += ApplicationParameter.TRIPLET_LENGTH.MAXLISTCOUNT_LENGTH; |
| break; |
| case ApplicationParameter.TRIPLET_TAGID.LISTSTARTOFFSET_TAGID: |
| i += 2; |
| int highValue = appParam[i] & 0xff; |
| int lowValue = appParam[i + 1] & 0xff; |
| appParamValue.listStartOffset = highValue * 256 + lowValue; |
| i += ApplicationParameter.TRIPLET_LENGTH.LISTSTARTOFFSET_LENGTH; |
| break; |
| case ApplicationParameter.TRIPLET_TAGID.FORMAT_TAGID: |
| i += 2;// length field in triplet |
| if (appParam[i] != 0) { |
| appParamValue.vcard21 = false; |
| } |
| i += ApplicationParameter.TRIPLET_LENGTH.FORMAT_LENGTH; |
| break; |
| default: |
| parseOk = false; |
| Log.e(TAG, "Parse Application Parameter error"); |
| break; |
| } |
| } |
| |
| if (D) appParamValue.dump(); |
| |
| return parseOk; |
| } |
| |
| /** Form and Send an XML format String to client for Phone book listing */ |
| private final int sendVcardListingXml(final int type, Operation op, |
| final int maxListCount, final int listStartOffset, final String searchValue, |
| String searchAttr) { |
| StringBuilder result = new StringBuilder(); |
| int itemsFound = 0; |
| result.append("<?xml version=\"1.0\"?>"); |
| result.append("<!DOCTYPE vcard-listing SYSTEM \"vcard-listing.dtd\">"); |
| result.append("<vCard-listing version=\"1.0\">"); |
| |
| // Phonebook listing request |
| if (type == ContentType.PHONEBOOK) { |
| if (searchAttr.equals("0")) { // search by name |
| itemsFound = createList(maxListCount, listStartOffset, searchValue, result, |
| "name"); |
| } else if (searchAttr.equals("1")) { // search by number |
| itemsFound = createList(maxListCount, listStartOffset, searchValue, result, |
| "number"); |
| }// end of search by number |
| else { |
| return ResponseCodes.OBEX_HTTP_PRECON_FAILED; |
| } |
| } |
| // Call history listing request |
| else { |
| ArrayList<String> nameList = mVcardManager.loadCallHistoryList(type); |
| int requestSize = nameList.size() >= maxListCount ? maxListCount : nameList.size(); |
| int startPoint = listStartOffset; |
| int endPoint = startPoint + requestSize; |
| if (endPoint > nameList.size()) { |
| endPoint = nameList.size(); |
| } |
| if (D) Log.d(TAG, "call log list, size=" + requestSize + " offset=" + listStartOffset); |
| |
| for (int j = startPoint; j < endPoint; j++) { |
| // listing object begin with 1.vcf |
| result.append("<card handle=\"" + (j + 1) + ".vcf\" name=\"" + nameList.get(j) |
| + "\"" + "/>"); |
| itemsFound++; |
| } |
| } |
| result.append("</vCard-listing>"); |
| |
| if (V) Log.v(TAG, "itemsFound =" + itemsFound); |
| |
| return pushBytes(op, result.toString()); |
| } |
| |
| private int createList(final int maxListCount, final int listStartOffset, |
| final String searchValue, StringBuilder result, String type) { |
| int itemsFound = 0; |
| ArrayList<String> nameList = mVcardManager.getPhonebookNameList(mOrderBy); |
| final int requestSize = nameList.size() >= maxListCount ? maxListCount : nameList.size(); |
| final int listSize = nameList.size(); |
| String compareValue = "", currentValue; |
| |
| if (D) Log.d(TAG, "search by " + type + ", requestSize=" + requestSize + " offset=" |
| + listStartOffset + " searchValue=" + searchValue); |
| |
| if (type.equals("number")) { |
| // query the number, to get the names |
| ArrayList<String> names = mVcardManager.getContactNamesByNumber(searchValue); |
| for (int i = 0; i < names.size(); i++) { |
| compareValue = names.get(i).trim(); |
| if (D) Log.d(TAG, "compareValue=" + compareValue); |
| for (int pos = listStartOffset; pos < listSize && |
| itemsFound < requestSize; pos++) { |
| currentValue = nameList.get(pos); |
| if (D) Log.d(TAG, "currentValue=" + currentValue); |
| if (currentValue.startsWith(compareValue)) { |
| itemsFound++; |
| result.append("<card handle=\"" + pos + ".vcf\" name=\"" |
| + currentValue + "\"" + "/>"); |
| } |
| } |
| if (itemsFound >= requestSize) { |
| break; |
| } |
| } |
| } else { |
| if (searchValue != null) { |
| compareValue = searchValue.trim(); |
| } |
| for (int pos = listStartOffset; pos < listSize && |
| itemsFound < requestSize; pos++) { |
| currentValue = nameList.get(pos); |
| if (D) Log.d(TAG, "currentValue=" + currentValue); |
| if (searchValue == null || currentValue.startsWith(compareValue)) { |
| itemsFound++; |
| result.append("<card handle=\"" + pos + ".vcf\" name=\"" |
| + currentValue + "\"" + "/>"); |
| } |
| } |
| } |
| return itemsFound; |
| } |
| |
| /** |
| * Function to send obex header back to client such as get phonebook size |
| * request |
| */ |
| private final int pushHeader(final Operation op, final HeaderSet reply) { |
| OutputStream outputStream = null; |
| |
| if (D) Log.d(TAG, "Push Header"); |
| if (D) Log.d(TAG, reply.toString()); |
| |
| int pushResult = ResponseCodes.OBEX_HTTP_OK; |
| try { |
| op.sendHeaders(reply); |
| outputStream = op.openOutputStream(); |
| outputStream.flush(); |
| } catch (IOException e) { |
| Log.e(TAG, e.toString()); |
| pushResult = ResponseCodes.OBEX_HTTP_INTERNAL_ERROR; |
| } finally { |
| if (!closeStream(outputStream, op)) { |
| pushResult = ResponseCodes.OBEX_HTTP_INTERNAL_ERROR; |
| } |
| } |
| return pushResult; |
| } |
| |
| /** Function to send vcard data to client */ |
| private final int pushBytes(Operation op, final String vcardString) { |
| if (vcardString == null) { |
| Log.w(TAG, "vcardString is null!"); |
| return ResponseCodes.OBEX_HTTP_OK; |
| } |
| |
| OutputStream outputStream = null; |
| int pushResult = ResponseCodes.OBEX_HTTP_OK; |
| try { |
| outputStream = op.openOutputStream(); |
| outputStream.write(vcardString.getBytes()); |
| if (V) Log.v(TAG, "Send Data complete!"); |
| } catch (IOException e) { |
| Log.e(TAG, "open/write outputstrem failed" + e.toString()); |
| pushResult = ResponseCodes.OBEX_HTTP_INTERNAL_ERROR; |
| } |
| |
| if (!closeStream(outputStream, op)) { |
| pushResult = ResponseCodes.OBEX_HTTP_INTERNAL_ERROR; |
| } |
| |
| return pushResult; |
| } |
| |
| private final int handleAppParaForResponse(AppParamValue appParamValue, int size, |
| HeaderSet reply, Operation op) { |
| byte[] misnum = new byte[1]; |
| ApplicationParameter ap = new ApplicationParameter(); |
| |
| // In such case, PCE only want the number of index. |
| // So response not contain any Body header. |
| if (mNeedPhonebookSize) { |
| if (V) Log.v(TAG, "Need Phonebook size in response header."); |
| mNeedPhonebookSize = false; |
| |
| byte[] pbsize = new byte[2]; |
| |
| pbsize[0] = (byte)((size / 256) & 0xff);// HIGH VALUE |
| pbsize[1] = (byte)((size % 256) & 0xff);// LOW VALUE |
| ap.addAPPHeader(ApplicationParameter.TRIPLET_TAGID.PHONEBOOKSIZE_TAGID, |
| ApplicationParameter.TRIPLET_LENGTH.PHONEBOOKSIZE_LENGTH, pbsize); |
| |
| if (mNeedNewMissedCallsNum) { |
| mNeedNewMissedCallsNum = false; |
| int nmnum = size - mMissedCallSize; |
| mMissedCallSize = size; |
| |
| nmnum = nmnum > 0 ? nmnum : 0; |
| misnum[0] = (byte)nmnum; |
| ap.addAPPHeader(ApplicationParameter.TRIPLET_TAGID.NEWMISSEDCALLS_TAGID, |
| ApplicationParameter.TRIPLET_LENGTH.NEWMISSEDCALLS_LENGTH, misnum); |
| if (D) Log.d(TAG, "handleAppParaForResponse(): mNeedNewMissedCallsNum=true, num= " |
| + nmnum); |
| } |
| reply.setHeader(HeaderSet.APPLICATION_PARAMETER, ap.getAPPparam()); |
| |
| if (D) Log.d(TAG, "Send back Phonebook size only, without body info! Size= " + size); |
| |
| return pushHeader(op, reply); |
| } |
| |
| // Only apply to "mch" download/listing. |
| // NewMissedCalls is used only in the response, together with Body |
| // header. |
| if (mNeedNewMissedCallsNum) { |
| if (V) Log.v(TAG, "Need new missed call num in response header."); |
| mNeedNewMissedCallsNum = false; |
| |
| int nmnum = size - mMissedCallSize; |
| mMissedCallSize = size; |
| |
| nmnum = nmnum > 0 ? nmnum : 0; |
| misnum[0] = (byte)nmnum; |
| ap.addAPPHeader(ApplicationParameter.TRIPLET_TAGID.NEWMISSEDCALLS_TAGID, |
| ApplicationParameter.TRIPLET_LENGTH.NEWMISSEDCALLS_LENGTH, misnum); |
| reply.setHeader(HeaderSet.APPLICATION_PARAMETER, ap.getAPPparam()); |
| if (D) Log.d(TAG, "handleAppParaForResponse(): mNeedNewMissedCallsNum=true, num= " |
| + nmnum); |
| |
| // Only Specifies the headers, not write for now, will write to PCE |
| // together with Body |
| try { |
| op.sendHeaders(reply); |
| } catch (IOException e) { |
| Log.e(TAG, e.toString()); |
| return ResponseCodes.OBEX_HTTP_INTERNAL_ERROR; |
| } |
| } |
| return NEED_SEND_BODY; |
| } |
| |
| private final int pullVcardListing(byte[] appParam, AppParamValue appParamValue, |
| HeaderSet reply, Operation op) { |
| String searchAttr = appParamValue.searchAttr.trim(); |
| |
| if (searchAttr == null || searchAttr.length() == 0) { |
| // If searchAttr is not set by PCE, set default value per spec. |
| appParamValue.searchAttr = "0"; |
| if (D) Log.d(TAG, "searchAttr is not set by PCE, assume search by name by default"); |
| } else if (!searchAttr.equals("0") && !searchAttr.equals("1")) { |
| Log.w(TAG, "search attr not supported"); |
| if (searchAttr.equals("2")) { |
| // search by sound is not supported currently |
| Log.w(TAG, "do not support search by sound"); |
| return ResponseCodes.OBEX_HTTP_NOT_IMPLEMENTED; |
| } |
| return ResponseCodes.OBEX_HTTP_PRECON_FAILED; |
| } else { |
| Log.i(TAG, "searchAttr is valid: " + searchAttr); |
| } |
| |
| int size = mVcardManager.getPhonebookSize(appParamValue.needTag); |
| int needSendBody = handleAppParaForResponse(appParamValue, size, reply, op); |
| if (needSendBody != NEED_SEND_BODY) { |
| return needSendBody; |
| } |
| |
| if (size == 0) { |
| if (V) Log.v(TAG, "PhonebookSize is 0, return."); |
| return ResponseCodes.OBEX_HTTP_OK; |
| } |
| |
| String orderPara = appParamValue.order.trim(); |
| if (TextUtils.isEmpty(orderPara)) { |
| // If order parameter is not set by PCE, set default value per spec. |
| orderPara = "0"; |
| if (D) Log.d(TAG, "Order parameter is not set by PCE. " + |
| "Assume order by 'Indexed' by default"); |
| } else if (!orderPara.equals("0") && !orderPara.equals("1")) { |
| if (V) Log.v(TAG, "Order parameter is not supported: " + appParamValue.order); |
| if (orderPara.equals("2")) { |
| // Order by sound is not supported currently |
| Log.w(TAG, "Do not support order by sound"); |
| return ResponseCodes.OBEX_HTTP_NOT_IMPLEMENTED; |
| } |
| return ResponseCodes.OBEX_HTTP_PRECON_FAILED; |
| } else { |
| Log.i(TAG, "Order parameter is valid: " + orderPara); |
| } |
| |
| if (orderPara.equals("0")) { |
| mOrderBy = ORDER_BY_INDEXED; |
| } else if (orderPara.equals("1")) { |
| mOrderBy = ORDER_BY_ALPHABETICAL; |
| } |
| |
| int sendResult = sendVcardListingXml(appParamValue.needTag, op, appParamValue.maxListCount, |
| appParamValue.listStartOffset, appParamValue.searchValue, |
| appParamValue.searchAttr); |
| return sendResult; |
| } |
| |
| private final int pullVcardEntry(byte[] appParam, AppParamValue appParamValue, |
| Operation op, final String name, final String current_path) { |
| if (name == null || name.length() < VCARD_NAME_SUFFIX_LENGTH) { |
| if (D) Log.d(TAG, "Name is Null, or the length of name < 5 !"); |
| return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE; |
| } |
| String strIndex = name.substring(0, name.length() - VCARD_NAME_SUFFIX_LENGTH + 1); |
| int intIndex = 0; |
| if (strIndex.trim().length() != 0) { |
| try { |
| intIndex = Integer.parseInt(strIndex); |
| } catch (NumberFormatException e) { |
| Log.e(TAG, "catch number format exception " + e.toString()); |
| return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE; |
| } |
| } |
| |
| int size = mVcardManager.getPhonebookSize(appParamValue.needTag); |
| if (size == 0) { |
| if (V) Log.v(TAG, "PhonebookSize is 0, return."); |
| return ResponseCodes.OBEX_HTTP_NOT_FOUND; |
| } |
| |
| boolean vcard21 = appParamValue.vcard21; |
| if (appParamValue.needTag == 0) { |
| Log.w(TAG, "wrong path!"); |
| return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE; |
| } else if (appParamValue.needTag == ContentType.PHONEBOOK) { |
| if (intIndex < 0 || intIndex >= size) { |
| Log.w(TAG, "The requested vcard is not acceptable! name= " + name); |
| return ResponseCodes.OBEX_HTTP_NOT_FOUND; |
| } else if (intIndex == 0) { |
| // For PB_PATH, 0.vcf is the phone number of this phone. |
| String ownerVcard = mVcardManager.getOwnerPhoneNumberVcard(vcard21); |
| return pushBytes(op, ownerVcard); |
| } else { |
| return mVcardManager.composeAndSendPhonebookOneVcard(op, intIndex, vcard21, null, |
| mOrderBy ); |
| } |
| } else { |
| if (intIndex <= 0 || intIndex > size) { |
| Log.w(TAG, "The requested vcard is not acceptable! name= " + name); |
| return ResponseCodes.OBEX_HTTP_NOT_FOUND; |
| } |
| // For others (ich/och/cch/mch), 0.vcf is meaningless, and must |
| // begin from 1.vcf |
| if (intIndex >= 1) { |
| return mVcardManager.composeAndSendCallLogVcards(appParamValue.needTag, op, |
| intIndex, intIndex, vcard21); |
| } |
| } |
| return ResponseCodes.OBEX_HTTP_OK; |
| } |
| |
| private final int pullPhonebook(byte[] appParam, AppParamValue appParamValue, HeaderSet reply, |
| Operation op, final String name) { |
| // code start for passing PTS3.2 TC_PSE_PBD_BI_01_C |
| if (name != null) { |
| int dotIndex = name.indexOf("."); |
| String vcf = "vcf"; |
| if (dotIndex >= 0 && dotIndex <= name.length()) { |
| if (name.regionMatches(dotIndex + 1, vcf, 0, vcf.length()) == false) { |
| Log.w(TAG, "name is not .vcf"); |
| return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE; |
| } |
| } |
| } // code end for passing PTS3.2 TC_PSE_PBD_BI_01_C |
| |
| int pbSize = mVcardManager.getPhonebookSize(appParamValue.needTag); |
| int needSendBody = handleAppParaForResponse(appParamValue, pbSize, reply, op); |
| if (needSendBody != NEED_SEND_BODY) { |
| return needSendBody; |
| } |
| |
| if (pbSize == 0) { |
| if (V) Log.v(TAG, "PhonebookSize is 0, return."); |
| return ResponseCodes.OBEX_HTTP_OK; |
| } |
| |
| int requestSize = pbSize >= appParamValue.maxListCount ? appParamValue.maxListCount |
| : pbSize; |
| int startPoint = appParamValue.listStartOffset; |
| if (startPoint < 0 || startPoint >= pbSize) { |
| Log.w(TAG, "listStartOffset is not correct! " + startPoint); |
| return ResponseCodes.OBEX_HTTP_OK; |
| } |
| |
| // Limit the number of call log to CALLLOG_NUM_LIMIT |
| if (appParamValue.needTag != BluetoothPbapObexServer.ContentType.PHONEBOOK) { |
| if (requestSize > CALLLOG_NUM_LIMIT) { |
| requestSize = CALLLOG_NUM_LIMIT; |
| } |
| } |
| |
| int endPoint = startPoint + requestSize - 1; |
| if (endPoint > pbSize - 1) { |
| endPoint = pbSize - 1; |
| } |
| if (D) Log.d(TAG, "pullPhonebook(): requestSize=" + requestSize + " startPoint=" + |
| startPoint + " endPoint=" + endPoint); |
| |
| boolean vcard21 = appParamValue.vcard21; |
| if (appParamValue.needTag == BluetoothPbapObexServer.ContentType.PHONEBOOK) { |
| if (startPoint == 0) { |
| String ownerVcard = mVcardManager.getOwnerPhoneNumberVcard(vcard21); |
| if (endPoint == 0) { |
| return pushBytes(op, ownerVcard); |
| } else { |
| return mVcardManager.composeAndSendPhonebookVcards(op, 1, endPoint, vcard21, |
| ownerVcard); |
| } |
| } else { |
| return mVcardManager.composeAndSendPhonebookVcards(op, startPoint, endPoint, |
| vcard21, null); |
| } |
| } else { |
| return mVcardManager.composeAndSendCallLogVcards(appParamValue.needTag, op, |
| startPoint + 1, endPoint + 1, vcard21); |
| } |
| } |
| |
| public static boolean closeStream(final OutputStream out, final Operation op) { |
| boolean returnvalue = true; |
| try { |
| if (out != null) { |
| out.close(); |
| } |
| } catch (IOException e) { |
| Log.e(TAG, "outputStream close failed" + e.toString()); |
| returnvalue = false; |
| } |
| try { |
| if (op != null) { |
| op.close(); |
| } |
| } catch (IOException e) { |
| Log.e(TAG, "operation close failed" + e.toString()); |
| returnvalue = false; |
| } |
| return returnvalue; |
| } |
| |
| // Reserved for future use. In case PSE challenge PCE and PCE input wrong |
| // session key. |
| public final void onAuthenticationFailure(final byte[] userName) { |
| } |
| |
| public static final String createSelectionPara(final int type) { |
| String selection = null; |
| switch (type) { |
| case ContentType.INCOMING_CALL_HISTORY: |
| selection = Calls.TYPE + "=" + CallLog.Calls.INCOMING_TYPE; |
| break; |
| case ContentType.OUTGOING_CALL_HISTORY: |
| selection = Calls.TYPE + "=" + CallLog.Calls.OUTGOING_TYPE; |
| break; |
| case ContentType.MISSED_CALL_HISTORY: |
| selection = Calls.TYPE + "=" + CallLog.Calls.MISSED_TYPE; |
| break; |
| default: |
| break; |
| } |
| if (V) Log.v(TAG, "Call log selection: " + selection); |
| return selection; |
| } |
| |
| public static final void logHeader(HeaderSet hs) { |
| Log.v(TAG, "Dumping HeaderSet " + hs.toString()); |
| try { |
| |
| Log.v(TAG, "COUNT : " + hs.getHeader(HeaderSet.COUNT)); |
| Log.v(TAG, "NAME : " + hs.getHeader(HeaderSet.NAME)); |
| Log.v(TAG, "TYPE : " + hs.getHeader(HeaderSet.TYPE)); |
| Log.v(TAG, "LENGTH : " + hs.getHeader(HeaderSet.LENGTH)); |
| Log.v(TAG, "TIME_ISO_8601 : " + hs.getHeader(HeaderSet.TIME_ISO_8601)); |
| Log.v(TAG, "TIME_4_BYTE : " + hs.getHeader(HeaderSet.TIME_4_BYTE)); |
| Log.v(TAG, "DESCRIPTION : " + hs.getHeader(HeaderSet.DESCRIPTION)); |
| Log.v(TAG, "TARGET : " + hs.getHeader(HeaderSet.TARGET)); |
| Log.v(TAG, "HTTP : " + hs.getHeader(HeaderSet.HTTP)); |
| Log.v(TAG, "WHO : " + hs.getHeader(HeaderSet.WHO)); |
| Log.v(TAG, "OBJECT_CLASS : " + hs.getHeader(HeaderSet.OBJECT_CLASS)); |
| Log.v(TAG, "APPLICATION_PARAMETER : " + hs.getHeader(HeaderSet.APPLICATION_PARAMETER)); |
| } catch (IOException e) { |
| Log.e(TAG, "dump HeaderSet error " + e); |
| } |
| } |
| } |
