(and substr:"phone" repo:droid) with options &zoekt.SearchOptions{EstimateDocCount:false, Whole:false, ShardMaxMatchCount:250, TotalMaxMatchCount:1000000, ShardMaxImportantMatch:2, TotalMaxImportantMatch:100, MaxWallTime:10000000000}

3: public class Phone {

52:       phone: to,

1: [{"phone": "Phone1", "battor": "Battor1"}, {"phone": "Phone2", "battor": "Battor2"}, {"phone": "Phone3", "battor": "Battor3"}]

32: 	   internal string phone;

159: 	  public virtual string Phone

158: 	  /// <returns> the phone </returns>

163: 			return phone;

167: 			this.phone = value;

22:   String phone;

173:   public String getPhone() {

180:   public void setPhone(String phone) {

171:    * @return the phone

174:     return phone;

178:    * @param phone the phone to set

181:     this.phone = phone;

19:   repeated PhoneNumber phone = 4 [(nanopb).max_count = 5];

8:   enum PhoneType {

14:   message PhoneNumber {

16:     optional PhoneType type = 2 [default = HOME];

1: [{"phone": "Phone1", "battor": "BattOr1"}, {"phone": "Phone2", "battor": "BattOr2"}, {"phone": "Phone3", "battor": "BattOr3"}]

752:         String phone;

751:     static class PhoneRow implements UntypedRow {

755:         public PhoneRow(String _phone, int _type) {

1154:         public void addPhone(Entity entity, int type, String phone) {

70:     private static final int MAX_PHONE_ROWS = 2;

25: import android.provider.ContactsContract.CommonDataKinds.Phone;

72:     private static final String COMMON_TYPE_ROW = Phone.TYPE; // Could have been any typed row

148:                     workPhones.add(new PhoneRow(getValue(), Phone.TYPE_WORK));

151:                     ops.addPhone(entity, Phone.TYPE_MMS, getValue());

154:                     ops.addPhone(entity, Phone.TYPE_FAX_WORK, getValue());

156:                 case Tags.CONTACTS2_COMPANY_MAIN_PHONE:

157:                     ops.addPhone(entity, Phone.TYPE_COMPANY_MAIN, getValue());

160:                     ops.addPhone(entity, Phone.TYPE_FAX_HOME, getValue());

164:                     homePhones.add(new PhoneRow(getValue(), Phone.TYPE_HOME));

167:                     ops.addPhone(entity, Phone.TYPE_MOBILE, getValue());

170:                     ops.addPhone(entity, Phone.TYPE_CAR, getValue());

173:                     ops.addPhone(entity, Phone.TYPE_RADIO, getValue());

176:                     ops.addPhone(entity, Phone.TYPE_PAGER, getValue());

179:                     ops.addPhone(entity, Phone.TYPE_ASSISTANT, getValue());

322:         ops.addUntyped(entity, homePhones, Phone.CONTENT_ITEM_TYPE, Phone.TYPE_HOME,

323:                 MAX_PHONE_ROWS);

324:         ops.addUntyped(entity, workPhones, Phone.CONTENT_ITEM_TYPE, Phone.TYPE_WORK,

325:                 MAX_PHONE_ROWS);

756:             phone = _phone;

762:             builder.withValue(Im.DATA, phone);

763:             builder.withValue(Phone.TYPE, type);

768:             return type == _type && phone.equalsIgnoreCase(value);

931:                             final int subtype = cv.getAsInteger(Phone.TYPE);

1155:             RowBuilder builder = typedRowBuilder(entity, Phone.CONTENT_ITEM_TYPE, type);

1157:             if (cv != null && cvCompareString(cv, Phone.NUMBER, phone)) {

1160:             builder.withValue(Phone.TYPE, type);

1161:             builder.withValue(Phone.NUMBER, phone);

146:                 case Tags.CONTACTS_BUSINESS2_TELEPHONE_NUMBER:

147:                 case Tags.CONTACTS_BUSINESS_TELEPHONE_NUMBER:

162:                 case Tags.CONTACTS_HOME_TELEPHONE_NUMBER:

163:                 case Tags.CONTACTS_HOME2_TELEPHONE_NUMBER:

166:                 case Tags.CONTACTS_MOBILE_TELEPHONE_NUMBER:

169:                 case Tags.CONTACTS_CAR_TELEPHONE_NUMBER:

172:                 case Tags.CONTACTS_RADIO_TELEPHONE_NUMBER:

178:                 case Tags.CONTACTS_ASSISTANT_TELEPHONE_NUMBER:

1091:                     cvCompareString(cv, StructuredName.PHONETIC_GIVEN_NAME, yomiFirstName) &&

1092:                     cvCompareString(cv, StructuredName.PHONETIC_FAMILY_NAME, yomiLastName) &&

1100:             builder.withValue(StructuredName.PHONETIC_GIVEN_NAME, yomiFirstName);

1101:             builder.withValue(StructuredName.PHONETIC_FAMILY_NAME, yomiLastName);

1298:                     cvCompareString(cv, Organization.PHONETIC_NAME, yomiCompanyName) &&

1308:             builder.withValue(Organization.PHONETIC_NAME, yomiCompanyName);

115:         ArrayList<UntypedRow> homePhones = new ArrayList<UntypedRow>();

116:         ArrayList<UntypedRow> workPhones = new ArrayList<UntypedRow>();

duplicate result

75:     class Phone {

78:         public Phone(String n) {

105:         private class RepresentPhone implements Represent {

119:         private class ConstructPhone extends AbstractConstruct {

141:         private class RepresentPhone implements Represent {

43:         yaml.addImplicitResolver(new Tag(Tag.PREFIX + "Phone"), regexp, "0123456789");

44:         Phone phone1 = new Phone("12-34-567");

45:         Phone phone2 = new Phone("11-22-333");

46:         Phone phone3 = new Phone("44-55-777");

47:         List<Phone> etalonList = new ArrayList<Phone>();

48:         etalonList.add(phone1);

49:         etalonList.add(phone2);

50:         etalonList.add(phone3);

53:         List<Phone> parsedList = (List<Phone>) yaml.load(output);

55:         assertEquals(phone1, parsedList.get(0));

56:         assertEquals(phone2, parsedList.get(1));

57:         assertEquals(phone3, parsedList.get(2));

64:         yaml.addImplicitResolver(new Tag(Tag.PREFIX + "Phone"), regexp, "\0");

69:         map.put("a", new Phone("12-34-567"));

88:             if (!(obj instanceof Phone)) {

96:             return "Phone: " + number;

102:             this.representers.put(Phone.class, new RepresentPhone());

107:                 Phone phone = (Phone) data;

108:                 String value = phone.getNumber();

109:                 return representScalar(new Tag(Tag.PREFIX + "Phone"), value);

116:             this.yamlConstructors.put(new Tag(Tag.PREFIX + "Phone"), new ConstructPhone());

122:                 return new Phone(val);

130:             this.representers.put(Phone.class, new RepresentPhone());

135:                 Point phone = (Point) data;

136:                 String value = "x" + (int) phone.getX() + "_y" + (int) phone.getY();

143:                 Phone phone = (Phone) data;

144:                 String value = phone.getNumber();

145:                 return representScalar(new Tag(Tag.PREFIX + "Phone"), value);

32:     private static String phone = "+1 650 253 0000";

40:         String formattedText = String.format(text, phone);

46:         String wrappedPhone = BidiFormatter.getInstance(true /* rtlContext */).unicodeWrap(phone);

47:         formattedText = String.format(text, wrappedPhone);

279:         class Phone(Structure):

312:         class Phone(Structure):

285:                         ("phone", Phone),

291:         self.assertEqual(p.phone.areacode, "1234")

292:         self.assertEqual(p.phone.number, "5678")

318:                         ("phone", Phone),

326:                                  "(Phone) <type 'exceptions.TypeError'>: "

331:                                  "(Phone) exceptions.TypeError: "

338:                                  "(Phone) <type 'exceptions.TypeError'>: too many initializers")

340:             self.assertEqual(msg, "(Phone) exceptions.TypeError: too many initializers")

duplicate result

28:   public $phone;

79:   public function setPhone($phone)

83:   public function getPhone()

81:     $this->phone = $phone;

85:     return $this->phone;

42:   char phone[SCRIPT_LEN];

52:     char phone[SCRIPT_LEN];	/* What to dial */

58:     protected static final String PHONE = "phone";

28:     private String phone;

46:     public String getPhone() {

50:     public void setPhone(String phone) {

47:         return phone;

51:         this.phone = phone;

86:         if (phone != null ? !phone.equals(owner.phone) : owner.phone != null) return false;

101:         result = 29 * result + (phone != null ? phone.hashCode() : 0);

24:   repeated PhoneNumber phone = 4;

13:   enum PhoneType {

19:   message PhoneNumber {

21:     optional PhoneType type = 2 [default = HOME];

166:     public static final Icon Phone = load("/icons/nele/phone.png");

83:     public static final Icon Mobile_32 = load("/icons/formfactors/phone_tablet_32.png"); // 32x32

89:     public static final Icon Mobile_64 = load("/icons/formfactors/64/phone_tablet.png"); // 64x64

39:     xmlChar *phone;

89:     if (cur->phone) printf("	phone: %s\n", cur->phone);

duplicate result

42:     private static final int MY_PERMISSIONS_REQUEST_CALL_PHONE = 1;

17: package com.example.android.phonecallingsample;

96:     private void checkForPhonePermission() {

175:     private class MyPhoneCallListener extends PhoneStateListener {

37:  * This app accepts a phone number and makes a phone call.

50:      *     Checks for phone permission.

65:             // Check for phone permission.

67:             // Register the PhoneStateListener to monitor phone activity.

94:      * Checks whether the app has phone-calling permission.

98:                 Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {

101:             // MY_PERMISSIONS_REQUEST_CALL_PHONE is an

105:                     new String[]{Manifest.permission.CALL_PHONE},

106:                     MY_PERMISSIONS_REQUEST_CALL_PHONE);

126:             case MY_PERMISSIONS_REQUEST_CALL_PHONE: {

127:                 if (permissions[0].equalsIgnoreCase(Manifest.permission.CALL_PHONE)

144:      * Uses an implicit intent to make the phone call.

147:      * @param view View (phone_icon) that was clicked.

151:         // Use format with "tel:" and phone number to create phoneNumber.

153:         // Log the concatenated phone number for dialing.

159:         // Set the data for the intent as the phone number.

161:         // If package resolves to an app, check for phone permission,

172:      * Monitors and logs phone call activities, and shows the phone state

181:             String message = getString(R.string.phone_status);

191:                     // Phone call is active -- off the hook.

198:                     // Phone is idle before and after phone call.

200:                     // restart activity when phone call ends.

217:                     message = message + "Phone off";

226:      * Makes the call button (phone_icon) invisible so that it can't be used,

230:         Toast.makeText(this, R.string.phone_disabled, Toast.LENGTH_LONG).show();

231:         ImageButton callButton = (ImageButton) findViewById(R.id.phone_icon);

240:      * Makes the call button (phone_icon) visible so that it can be used.

243:         ImageButton callButton = (ImageButton) findViewById(R.id.phone_icon);

27: import android.telephony.PhoneStateListener;

51:      *     Sets the PhoneStateListener.

69:             mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_CALL_STATE);

152:         String phoneNumber = String.format("tel: %s", editText.getText().toString());

154:         Log.d(TAG, getString(R.string.dial_number) + phoneNumber);

155:         Toast.makeText(this, getString(R.string.dial_number) + phoneNumber,

160:         callIntent.setData(Uri.parse(phoneNumber));

262:             mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_NONE);

45:     private MyPhoneCallListener mListener;

66:             checkForPhonePermission();

68:             mListener = new MyPhoneCallListener();

164:             checkForPhonePermission();

281: static bool phone_number_compare_inter(const char* const org_a, const char* const org_b,

431: bool phone_number_compare_strict(const char* a, const char* b)

440: bool phone_number_stripped_reversed_inter(const char* in, char* out, const int len, int *outlen) {

138:  * digit to compare two phone numbers.

260:  * Compare phone numbers a and b, return true if they're identical

268:  * "the display language is English but the phone should be in Japan", but

270:  * in the country where the phone is used. More specifically, "880-1234-1234"

271:  * is not valid phone number in Japan since the trunk prefix in Japan is not 8

312:             // Different Country Calling Code. Must be different phone number.

380:                 return phone_number_compare_inter(org_a, org_b, false);

388:                 return phone_number_compare_inter(org_a, org_b, false);

433:     return phone_number_compare_inter(a, b, true);

437:  * Imitates the Java method PhoneNumberUtils.getStrippedReversed.

195: bool phone_number_compare_loose(const char* a, const char* b)

18: // Old implementation for phone_number_compare(), which has used in cupcake, but once replaced with

40:  * Phone numbers are stored in "lookup" form in the database

43:  * This method takes a phone number and makes a valid SQL "LIKE"

185:  * Compare phone numbers a and b, return true if they're identical

345: #define TPM_PS_CELL_PHONE      0x00000003

277:     private SparseArray<String> mSubId2phone = new SparseArray<String>();

136:     private static final String SELF_PHONE_KEY = "self_phone";

278:     private Map<String, Integer> mPhone2subId = new ArrayMap<String, Integer>();

80:  *  [{"self_phone":"+1234567891011","address":"+1234567891012","body":"Example sms",

82:  *  {"self_phone":"+1234567891011","address":"12345","body":"Example 2","date":"1451328022316",

86:  *  [{"self_phone":"+1234567891011","date":"1451322716","date_sent":"0","m_type":"128","v":"18",

90:  *  {"self_phone":"+1234567891011","sub":"MMS subject","date":"1451322955","date_sent":"0",

135:     // JSON key for phone number a message was sent from or received to.

263:         // If there is no sub_id with self phone number on restore set it to -1.

303:                     mSubId2phone.append(sub.getSubscriptionId(), phoneNumber);

317:     void setSubId(SparseArray<String> subId2Phone, Map<String, Integer> phone2subId) {

318:         mSubId2phone = subId2Phone;

319:         mPhone2subId = phone2subId;

682:                     final String selfNumber = mSubId2phone.get(subId);

684:                         jsonWriter.name(SELF_PHONE_KEY).value(selfNumber);

773:                 case SELF_PHONE_KEY:

820:                     final String selfNumber = mSubId2phone.get(subId);

822:                         jsonWriter.name(SELF_PHONE_KEY).value(selfNumber);

866:                 case SELF_PHONE_KEY:

45: import android.telephony.PhoneNumberUtils;

302:                     final String phoneNumber = getNormalizedNumber(sub);

304:                     mPhone2subId.put(phoneNumber, sub.getSubscriptionId());

666:         return PhoneNumberUtils.formatNumberToE164(subscriptionInfo.getNumber(),

774:                     final String selfPhone = jsonReader.nextString();

775:                     if (mPhone2subId.containsKey(selfPhone)) {

776:                         values.put(Telephony.Sms.SUBSCRIPTION_ID, mPhone2subId.get(selfPhone));

867:                     final String selfPhone = jsonReader.nextString();

868:                     if (mPhone2subId.containsKey(selfPhone)) {

869:                         mms.values.put(Telephony.Mms.SUBSCRIPTION_ID, mPhone2subId.get(selfPhone));

1212:     // NOTE: There are phones on which you can't get the recipients from the thread id for SMS

109: HOME_PHONE   = "PHH"

110: WORK_PHONE   = "PHW"

111: MOBILE_PHONE = "PHM"

122: STATUS_PHONE   = 'PHN'

417:     def setPhone(self, phoneType, value):

1152:     def gotPhoneNumber(self, listVersion, userHandle, phoneType, number):

1384:     def setPhoneDetails(self, phoneType, value):

108: # phone constants

394:     @ivar homePhone: The contact's home phone number.

396:     @ivar workPhone: The contact's work phone number.

398:     @ivar mobilePhone: The contact's mobile phone number.

411:         # phone details

419:         set phone numbers/values for this specific user.

420:         for phoneType check the *_PHONE constants and HAS_PAGER

424:         if t == HOME_PHONE:

426:         elif t == WORK_PHONE:

428:         elif t == MOBILE_PHONE:

433:             raise ValueError, "Invalid Phone Type"

894:             phone = self._getStateData('phone')

896:             self._remStateData('lst_reply', 'lsg_reply', 'lst_sofar', 'phone', 'synid', 'list')

897:             self._fireCallback(id, contacts, phone)

939:             self._setStateData('phone', [])

956:             self._getStateData('phone').append((params[0], unquote(params[1])))

1154:         Called when the server sends us phone details about

1156:         the server will send their status, phone details etc.

1158:         factory's contact list and update the phone details

1164:                           (*_PHONE constants or HAS_PAGER)

1165:         @param number: the value/phone number.

1386:         Set/change my phone numbers stored on the server.

1389:                           constants - HOME_PHONE, WORK_PHONE,

1390:                           MOBILE_PHONE, HAS_PAGER.

1394:         @param value: for all of the *_PHONE constants the value is a

1395:                       phone number (str), for HAS_PAGER accepted values

1402:                  being the new phone number value (str).

1405:         # factory.contacts.version and the relevant phone

2419:     STATUS_PHONE   : "On the Phone",

395:     @type homePhone: str if known, otherwise None.

397:     @type workPhone: str if known, otherwise None.

399:     @type mobilePhone: str if known, otherwise None.

412:         self.homePhone   = None

413:         self.workPhone   = None

414:         self.mobilePhone = None

423:         t = phoneType.upper()

425:             self.homePhone = value

427:             self.workPhone = value

429:             self.mobilePhone = value

963:             self._getStateData('last_contact').setPhone(params[0], unquote(params[1]))

1163:         @param phoneType: the specific phoneType

1168:         self.factory.contacts.getContact(userHandle).setPhone(phoneType, number)

1388:         @param phoneType: phoneType can be one of the following

1408:         self.sendLine("PRP %s %s %s" % (id, phoneType, quote(value)))

965:             self.gotPhoneNumber(int(params[0]), params[1], params[2], unquote(params[3]))

86:     private static final int URI_MESSAGES_BY_PHONE                 = 3;

306:     private boolean mUseStrictPhoneNumberComparation;

1004:     private Cursor getMessagesByPhoneNumber(

260:                 URI_MESSAGES_BY_PHONE);

314:                     com.android.internal.R.bool.config_use_strict_phone_number_comparation);

323:         // caller's identity. Only system, phone or the default sms app can have full access

368:             case URI_MESSAGES_BY_PHONE:

540:             selection += " OR PHONE_NUMBERS_EQUAL(address, ?, " +

988:      * included this phone number.

996:      *              PHONE_NUMBERS_EQUAL(addr.address, '<phoneNumber>', 1/0)))

1002:      *   WHERE (address='<phoneNumber>' OR PHONE_NUMBERS_EQUAL(sms.address, '<phoneNumber>', 1/0));

1015:                         "(address=" + escapedPhoneNumber + " OR PHONE_NUMBERS_EQUAL(address, " +

1027:                 " OR PHONE_NUMBERS_EQUAL(addr.address, " +

1338:             // CREATOR should not be changed by non-SYSTEM/PHONE apps

259:                 AUTHORITY, "messages/byphone/*",

995:      *              WHERE (address='<phoneNumber>' OR

1005:             String phoneNumber, String[] projection, String selection,

1007:         String escapedPhoneNumber = DatabaseUtils.sqlEscapeString(phoneNumber);

312:         mUseStrictPhoneNumberComparation =

369:                 cursor = getMessagesByPhoneNumber(

526:         boolean isPhoneNumber = Mms.isPhoneNumber(address);

537:         if (!isPhoneNumber) {

541:                         (mUseStrictPhoneNumberComparation ? 1 : 0) + ")";

1016:                         escapedPhoneNumber +

1017:                         (mUseStrictPhoneNumberComparation ? ", 1))" : ", 0))"));

1026:                 "FROM addr WHERE (address=" + escapedPhoneNumber +

1028:                 escapedPhoneNumber +

1029:                 (mUseStrictPhoneNumberComparation ? ", 1))) " : ", 0))) ") +

99:     public static final int QUERY_TYPE_PHONE = 1;

510:      * First, each destination (an email address or a phone number) with a valid contactId is

604:         } else if (queryMode == QUERY_TYPE_PHONE) {

605:             mQueryMode = Queries.PHONE;

66: const uint8 PHONE_RTCP_SDES = 4;

41: #define PCI_CLASS_MULTIMEDIA_PHONE	0x0402

213:           DEVICE_PHONE = 2;

101:     // - iPhone OS

93:     private static final int MASK_SKB_LAYOUT_PHONE = 0x50000000;

46:     public static final int USERDEF_KEYCODE_PHONE_SYM_4 = -4;

184:     public static final int MODE_SKB_PHONE_NUM = (MASK_SKB_LAYOUT_PHONE);

189:     public static final int MODE_SKB_PHONE_SYM = (MASK_SKB_LAYOUT_PHONE | MASK_CASE_UPPER);

298:     private int mToggleStatePhoneSym;

122:      * bits are ignored. For phone keyboard layout, these bits can be

123:      * {@link #MASK_CASE_UPPER} to request symbol page for phone soft keyboard.

182:      * Mode for inputing phone numbers.

187:      * Mode for inputing phone numbers.

296:      * Key toggling state for phone symbol mode.

392:                 .getString(R.string.toggle_phone_sym));

432:         case MASK_SKB_LAYOUT_PHONE:

433:             return R.xml.skb_phone;

508:         } else if (USERDEF_KEYCODE_PHONE_SYM_4 == userKey) {

509:             if (MODE_SKB_PHONE_NUM == mInputMode) {

510:                 newInputMode = MODE_SKB_PHONE_SYM;

512:                 newInputMode = MODE_SKB_PHONE_NUM;

533:         case EditorInfo.TYPE_CLASS_PHONE:

583:         case EditorInfo.TYPE_CLASS_PHONE:

584:             newInputMode = MODE_SKB_PHONE_NUM;

703:                 || USERDEF_KEYCODE_PHONE_SYM_4 == keyCode) {

746:         if (MASK_SKB_LAYOUT_PHONE != layout) {

391:         mToggleStatePhoneSym = Integer.parseInt(r

790:                 states[statesNum] = mToggleStatePhoneSym;

75:     public static final String PHONE_TYPE_EXTRA = "phone_type";

186:     private static final int PHONE_ID_COUNT = 7;

26: import android.provider.ContactsContract.CommonDataKinds.Phone;

43:  * This is a RecognizerEngine that processes commands to make phone calls and

184:      * Number of phone ids appended to a grammer in {@link #addNameEntriesToGrammar(List)}.

204:             // The number of ids appended here must be same as PHONE_ID_COUNT.

917:      * Format a phone number string.

919:      * @param num phone number string.

920:      * @return formatted phone number string.

987:                     && commands.length >= PHONE_ID_COUNT + 1) {

1005:                 if (commands.length == PHONE_ID_COUNT + 2) {

1006:                     // The last command should imply the type of the phone number.

1007:                     final String spokenPhoneIdCommand = commands[PHONE_ID_COUNT + 1];

1016:                                 Phone.CONTENT_URI, spokenPhoneId),

1023:                 else if (commands.length == PHONE_ID_COUNT + 1) {

1044:                                 Phone.CONTENT_URI, primaryId),

1057:                     if (commands.length == PHONE_ID_COUNT + 2) {

1072:                                 Phone.CONTENT_URI, homeId),

1080:                                 Phone.CONTENT_URI, mobileId),

1088:                                 Phone.CONTENT_URI, workId),

1096:                                 Phone.CONTENT_URI, otherId),

1103:                                 Phone.CONTENT_URI, fallbackId),

1212:                 .putExtra(PHONE_TYPE_EXTRA, phoneType);

918:      * At some point, PhoneNumberUtils.formatNumber will handle this.

990:                 long primaryId   = Long.parseLong(commands[2]); // phones table

991:                 long homeId    = Long.parseLong(commands[3]); // phones table

992:                 long mobileId  = Long.parseLong(commands[4]); // phones table

993:                 long workId    = Long.parseLong(commands[5]); // phones table

994:                 long otherId   = Long.parseLong(commands[6]); // phones table

995:                 long fallbackId = Long.parseLong(commands[7]); // phones table

1022:                 // 'CALL JACK JONES', with valid default phoneId

1024:                     String phoneType = null;

1025:                     CharSequence phoneIdMsg = null;

1027:                         phoneType = null;

1028:                         phoneIdMsg = null;

1030:                         phoneType = "H";

1031:                         phoneIdMsg = res.getText(R.string.at_home);

1033:                         phoneType = "M";

1034:                         phoneIdMsg = res.getText(R.string.on_mobile);

1036:                         phoneType = "W";

1037:                         phoneIdMsg = res.getText(R.string.at_work);

1039:                         phoneType = "O";

1040:                         phoneIdMsg = res.getText(R.string.at_other);

1042:                     if (phoneIdMsg != null) {

1045:                                 literal + phoneIdMsg, phoneType, 0);

1069:                     //  add 'CALL JACK JONES at home' using phoneId

1208:             String phoneType, int flags) {

1008:                     long spokenPhoneId =

1009:                             "H".equalsIgnoreCase(spokenPhoneIdCommand) ? homeId :

1010:                             "M".equalsIgnoreCase(spokenPhoneIdCommand) ? mobileId :

1011:                             "W".equalsIgnoreCase(spokenPhoneIdCommand) ? workId :

1012:                             "O".equalsIgnoreCase(spokenPhoneIdCommand) ? otherId :

1014:                     if (spokenPhoneId != VoiceContact.ID_UNDEFINED) {

1017:                                 literal, spokenPhoneIdCommand, 0);

251: 	WPS_DEV_PHONE = 10

274: 	WPS_DEV_PHONE_WINDOWS_MOBILE = 1

88:     public static final String PRESENCE_MOBILE_PHONE = "MOBILE_PHONE";

37:     public static final int KEYCODE_PHONE  = -116;

36:     /** 12-key keyboard [PHONE MODE] */

43:      * keyboard(KEYMODE_EN_NUMBER) is active.  The phone number

44:      * keyboard(KEYMODE_EN_PHONE) is disabled.

83:         keyList[KEYMODE_EN_PHONE][0]    = new Keyboard(parent, R.xml.keyboard_12key_phone);

90:         keyList[KEYMODE_EN_PHONE][0]    = new Keyboard(parent, R.xml.keyboard_12key_phone);

168:         case EditorInfo.TYPE_CLASS_PHONE:

172:             mCurrentKeyMode      = KEYMODE_EN_PHONE;

213:         case KEYCODE_PHONE:

214:             this.changeKeyMode(KEYMODE_EN_PHONE);

226:                 } else if (TOGGLE_KEYBOARD[KEYMODE_EN_PHONE]) {

227:                     mCurrentKeyMode = KEYMODE_EN_PHONE;

231:                 if (TOGGLE_KEYBOARD[KEYMODE_EN_PHONE]) {

232:                     mCurrentKeyMode = KEYMODE_EN_PHONE;

237:             case KEYMODE_EN_PHONE:

223:     public static final int KEYMODE_EN_PHONE    = 2;

241:     public static final int KEYMODE_JA_HALF_PHONE    = 7;

251:     public static final int KEYMODE_CN_PHONE    = 3;

222:     /** English key-mode (phone number) */

240:     /** Japanese key-mode (Half-width phone number) */

250:     /** Chinese key-mode (phone) */

294: 	WPS_DEV_PHONE = 10,

357: 	WPS_DEV_AUDIO_MICROPHONE = 6,

347: 	WPS_DEV_PHONE_WINDOWS_MOBILE = 1,

348: 	WPS_DEV_PHONE_SINGLE_MODE = 2,

349: 	WPS_DEV_PHONE_DUAL_MODE = 3,

350: 	WPS_DEV_PHONE_SP_SINGLE_MODE = 4,

351: 	WPS_DEV_PHONE_SP_DUAL_MODE = 5,

356: 	WPS_DEV_AUDIO_HEADPHONES = 5,

26:     public static final int PHONE_ONLY_ID = 3;

432:     public static final int CONTACTS2_COMPANY_MAIN_PHONE = CONTACTS2_PAGE + 0xB;

549:     public static final int GAL_PHONE = GAL_PAGE + 6;

556:     public static final int GAL_HOME_PHONE = GAL_PAGE + 0xD;

557:     public static final int GAL_MOBILE_PHONE = GAL_PAGE + 0xE;

614:     public static final int SETTINGS_PHONE_NUMBER = SETTINGS_PAGE + 0x1C;

108:     public static final int CONTACTS_ASSISTANT_TELEPHONE_NUMBER = CONTACTS_PAGE + 7;

113:     public static final int CONTACTS_BUSINESS2_TELEPHONE_NUMBER = CONTACTS_PAGE + 0xC;

120:     public static final int CONTACTS_BUSINESS_TELEPHONE_NUMBER = CONTACTS_PAGE + 0x13;

121:     public static final int CONTACTS_CAR_TELEPHONE_NUMBER = CONTACTS_PAGE + 0x14;

133:     public static final int CONTACTS_HOME2_TELEPHONE_NUMBER = CONTACTS_PAGE + 0x20;

140:     public static final int CONTACTS_HOME_TELEPHONE_NUMBER = CONTACTS_PAGE + 0x27;

144:     public static final int CONTACTS_MOBILE_TELEPHONE_NUMBER = CONTACTS_PAGE + 0x2B;

152:     public static final int CONTACTS_RADIO_TELEPHONE_NUMBER = CONTACTS_PAGE + 0x33;

860:             "CompanyMainPhone", "AccountName", "NickName", "MMS"

900:             "GalDisplayName", "GalPhone", "GalOffice", "GalTitle", "GalCompany", "GalAlias",

901:             "GalFirstName", "GalLastName", "GalHomePhone", "GalMobilePhone", "GalEmailAddress",

918:             "PhoneNumber", "UserInformation", "EmailAddress", "StmpAddress", "UserAgent",

761:             "Anniversary", "AssistantName", "AssistantTelephoneNumber", "Birthday", "ContactsBody",

762:             "ContactsBodySize", "ContactsBodyTruncated", "Business2TelephoneNumber",

765:             "BusinessAddressStreet", "BusinessFaxNumber", "BusinessTelephoneNumber",

766:             "CarTelephoneNumber", "ContactsCategories", "ContactsCategory", "Children", "Child",

768:             "FileAs", "FirstName", "Home2TelephoneNumber", "HomeAddressCity", "HomeAddressCountry",

770:             "HomeTelephoneNumber", "JobTitle", "LastName", "MiddleName", "MobileTelephoneNumber",

773:             "RadioTelephoneNumber", "Spouse", "Suffix", "Title", "Webpage", "YomiCompanyName",

46:     private static final String PHONE_NUMBER_KEY = "phone_number";

36:     private String phoneNumber;

88:     public RedeemableDigitsSessionBuilder setPhoneNumber(@Nullable String phoneNumber) {

83:      * Set phone number

85:      * @param phoneNumber digits user's phone number

212:         builder.setPhoneNumber(safeGetString(PHONE_NUMBER_KEY, jsonObject));

89:         this.phoneNumber = phoneNumber;

198:         return new ClearSessionContinuation.RedeemableDigitsSession(id, phoneNumber, email, isEmailVerified, authToken,

54: #   define GTEST_OS_WINDOWS_PHONE 1

53: #  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)

67: # if TARGET_OS_IPHONE

48:         static final String PHONE_NUMBER = "phone";

69:                     + Profiles.PHONE_NUMBER + " TEXT"

108:                 Profiles.PHONE_NUMBER

duplicate result

30:     public static final String RESPONSE_PHONE = "phone";

44:         params.put("phone", phoneNo);

67:         params.put("phone", phoneNo);

77:                     phoneNo = response.getString(RESPONSE_PHONE);

94:         params.put("phone", phoneNo);

41:     public void request(String phoneNo, final RequestResponse successReceiver,

64:     public void verify(String phoneNo, String smsMessage, final VerifyResponse successReceiver,

74:                 String phoneNo = null;

81:                 successReceiver.onResponse(success, phoneNo);

91:     public void reset(String phoneNo, final ResetResponse successReceiver,

159:         public void onResponse(boolean success, String phoneNumber);

342: #define AUDIO_TERMINAL_DOWN_LINE_PHONE          0x0503

313: #define AUDIO_TERMINAL_MICROPHONE               0x0201

314: #define AUDIO_TERMINAL_DESKTOP_MICROPHONE       0x0202

315: #define AUDIO_TERMINAL_PERSONAL_MICROPHONE      0x0203

316: #define AUDIO_TERMINAL_OMNI_DIR_MICROPHONE      0x0204

334: #define AUDIO_TERMINAL_SPEAKERPHONE             0x0403

341: #define AUDIO_TERMINAL_TELEPHONE                0x0502

340: #define AUDIO_TERMINAL_PHONE_LINE               0x0501

317: #define AUDIO_TERMINAL_MICROPHONE_ARRAY         0x0205

335: #define AUDIO_TERMINAL_SPEAKERPHONE_ECHOSUPRESS 0x0404

336: #define AUDIO_TERMINAL_SPEAKERPHONE_ECHOCANCEL  0x0405

323: #define AUDIO_TERMINAL_HEADPHONES               0x0302

48:     public static final String PHONE_CONTEXT_TAG =

49:         ParameterNames.PHONE_CONTEXT_TAG;

51:     var PHONE_pattern = new RegExp("\\(?(\\d{3})\\)?-?(\\d{3})-(\\d{4})");

52:     // testing PHONE pattern

53: 	testcases[count++] = new TestCase ( SECTION, "'Our phone number is (408)345-2345.'.match(PHONE_pattern))",

54: 	                                    String(["(408)345-2345","408","345","2345"]), String('Our phone number is (408)345-2345.'.match(PHONE_pattern)));

56:     // testing PHONE pattern

57: 	testcases[count++] = new TestCase ( SECTION, "'The phone number is 408-345-2345!'.match(PHONE_pattern))",

58: 	                                    String(["408-345-2345","408","345","2345"]), String('The phone number is 408-345-2345!'.match(PHONE_pattern)));

60:     // testing PHONE pattern

61: 	testcases[count++] = new TestCase ( SECTION, "String(PHONE_pattern.toString())",

62: 	                                    "/\\(?(\\d{3})\\)?-?(\\d{3})-(\\d{4})/", String(PHONE_pattern.toString()));

65: 	testcases[count++] = new TestCase ( SECTION, "PHONE_pattern + ' is the string'",

66: 	                                    "/\\(?(\\d{3})\\)?-?(\\d{3})-(\\d{4})/ is the string",PHONE_pattern + ' is the string');

45:     public static final int TARGET_PHONE = 1;

126:             case TARGET_PHONE:

127:                 return R.xml.app_target_phone;