private void setQuickContactCursor(Cursor cursor) {

    if (cursor != null && cursor.moveToFirst()) {
      nativeContact = new QuickContactDetail();
      // contact.contactId = contactId;
      nativeContact.numbers = new ArrayList<NmsQuickContactActivity.QuickContactPhone>();
      do {
        String mimeType = cursor.getString(cursor.getColumnIndex(Data.MIMETYPE));
        if (mimeType.equals(StructuredName.CONTENT_ITEM_TYPE)) {
          String name = cursor.getString(cursor.getColumnIndex(StructuredName.DISPLAY_NAME));
          nativeContact.name = name;
        } else if (mimeType.equals(Phone.CONTENT_ITEM_TYPE)) {
          boolean isAdd = true;
          String number = cursor.getString(cursor.getColumnIndex(Phone.NUMBER));
          if (number == null) {
            continue;
          }
          for (int i = 0; i < nativeContact.numbers.size(); ++i) {
            if (number.equals(nativeContact.numbers.get(i).number)) {
              isAdd = false;
              break;
            }
          }
          if (!isAdd) {
            continue;
          }
          QuickContactPhone phone = new QuickContactPhone();
          phone.number = number;
          String lable =
              Phone.getTypeLabel(
                      getResources(),
                      cursor.getInt(cursor.getColumnIndex(Phone.TYPE)),
                      cursor.getString(cursor.getColumnIndex(Phone.LABEL)))
                  .toString();
          phone.isHissage = NmsIpMessageApiNative.nmsIsiSMSNumber(number);
          if (phone.isHissage) {
            phone.numberType = lable + this.getText(R.string.STR_NMS_ISMS_ENABLE).toString();
          } else {
            phone.numberType = lable;
          }

          nativeContact.numbers.add(phone);
        } else if (mimeType.equals(Photo.CONTENT_ITEM_TYPE)) {
          byte[] photoBytes = cursor.getBlob(cursor.getColumnIndex(Photo.PHOTO));
          if (photoBytes != null) {
            nativeContact.avatar = BitmapFactory.decodeByteArray(photoBytes, 0, photoBytes.length);
          }
        }
      } while (cursor.moveToNext());
    }
    if (cursor != null) {
      cursor.close();
    }

    updateUI();
  }
  protected void bindPhoneNumber(ContactListItemView view, Cursor cursor) {
    CharSequence label = null;
    if (!cursor.isNull(PHONE_TYPE_COLUMN_INDEX)) {
      final int type = cursor.getInt(PHONE_TYPE_COLUMN_INDEX);
      final String customLabel = cursor.getString(PHONE_LABEL_COLUMN_INDEX);

      // TODO cache
      label = Phone.getTypeLabel(getContext().getResources(), type, customLabel);
    }
    view.setLabel(label);
    view.showData(cursor, PHONE_NUMBER_COLUMN_INDEX);
  }
  private ContactEntry createContactEntryFromCursor(Cursor cursor, int position) {
    // If the loader was canceled we will be given a null cursor.
    // In that case, show an empty list of contacts.
    if (cursor == null || cursor.isClosed() || cursor.getCount() <= position) return null;

    cursor.moveToPosition(position);
    long id = cursor.getLong(mIdIndex);
    String photoUri = cursor.getString(mPhotoUriIndex);
    String lookupKey = cursor.getString(mLookupIndex);

    ContactEntry contact = new ContactEntry();
    String name = cursor.getString(mNameIndex);
    contact.name = (name != null) ? name : mResources.getString(R.string.missing_name);
    contact.status = cursor.getString(mStatusIndex);
    contact.photoUri = (photoUri != null ? Uri.parse(photoUri) : null);
    contact.lookupKey =
        ContentUris.withAppendedId(
            Uri.withAppendedPath(Contacts.CONTENT_LOOKUP_URI, lookupKey), id);

    // Set phone number and label
    if (mDisplayType == DisplayType.STREQUENT_PHONE_ONLY) {
      int phoneNumberType = cursor.getInt(mPhoneNumberTypeIndex);
      String phoneNumberCustomLabel = cursor.getString(mPhoneNumberLabelIndex);
      contact.phoneLabel =
          (String) Phone.getTypeLabel(mResources, phoneNumberType, phoneNumberCustomLabel);
      contact.phoneNumber = cursor.getString(mPhoneNumberIndex);
    } else {
      // Set presence icon and status message
      Drawable icon = null;
      int presence = 0;
      if (!cursor.isNull(mPresenceIndex)) {
        presence = cursor.getInt(mPresenceIndex);
        icon = ContactPresenceIconUtil.getPresenceIcon(mContext, presence);
      }
      contact.presenceIcon = icon;

      String statusMessage = null;
      if (mStatusIndex != 0 && !cursor.isNull(mStatusIndex)) {
        statusMessage = cursor.getString(mStatusIndex);
      }
      // If there is no status message from the contact, but there was a presence value,
      // then use the default status message string
      if (statusMessage == null && presence != 0) {
        statusMessage = ContactStatusUtil.getStatusString(mContext, presence);
      }
      contact.status = statusMessage;
    }

    return contact;
  }
 protected EditType buildPhoneType(int type) {
   return new EditType(type, Phone.getTypeLabelResource(type));
 }
    public void bindView(Context context, View view, Cursor c) {
      final RecentCallsListItemViews views = (RecentCallsListItemViews) view.getTag();

      String number = c.getString(NUMBER_COLUMN_INDEX);
      String formattedNumber = null;
      String callerName = c.getString(CALLER_NAME_COLUMN_INDEX);
      int callerNumberType = c.getInt(CALLER_NUMBERTYPE_COLUMN_INDEX);
      String callerNumberLabel = c.getString(CALLER_NUMBERLABEL_COLUMN_INDEX);

      // Store away the number so we can call it directly if you click on the call icon
      views.callView.setTag(number);

      // Lookup contacts with this number
      ContactInfo info = mContactInfo.get(number);
      if (info == null) {
        // Mark it as empty and queue up a request to find the name
        // The db request should happen on a non-UI thread
        info = ContactInfo.EMPTY;
        mContactInfo.put(number, info);
        enqueueRequest(number, c.getPosition(), callerName, callerNumberType, callerNumberLabel);
      } else if (info != ContactInfo.EMPTY) { // Has been queried
        // Check if any data is different from the data cached in the
        // calls db. If so, queue the request so that we can update
        // the calls db.
        if (!TextUtils.equals(info.name, callerName)
            || info.type != callerNumberType
            || !TextUtils.equals(info.label, callerNumberLabel)) {
          // Something is amiss, so sync up.
          enqueueRequest(number, c.getPosition(), callerName, callerNumberType, callerNumberLabel);
        }

        // Format and cache phone number for found contact
        if (info.formattedNumber == null) {
          info.formattedNumber = formatPhoneNumber(info.number);
        }
        formattedNumber = info.formattedNumber;
      }

      String name = info.name;
      int ntype = info.type;
      String label = info.label;
      // If there's no name cached in our hashmap, but there's one in the
      // calls db, use the one in the calls db. Otherwise the name in our
      // hashmap is more recent, so it has precedence.
      if (TextUtils.isEmpty(name) && !TextUtils.isEmpty(callerName)) {
        name = callerName;
        ntype = callerNumberType;
        label = callerNumberLabel;

        // Format the cached call_log phone number
        formattedNumber = formatPhoneNumber(number);
      }
      // Set the text lines and call icon.
      // Assumes the call back feature is on most of the
      // time. For private and unknown numbers: hide it.
      views.callView.setVisibility(View.VISIBLE);

      if (!TextUtils.isEmpty(name)) {
        views.line1View.setText(name);
        views.labelView.setVisibility(View.VISIBLE);

        // "type" and "label" are currently unused for SIP addresses.
        CharSequence numberLabel = null;
        if (!PhoneNumberUtils.isUriNumber(number)) {
          numberLabel = Phone.getDisplayLabel(context, ntype, label, mLabelArray);
        }
        views.numberView.setVisibility(View.VISIBLE);
        views.numberView.setText(formattedNumber);
        if (!TextUtils.isEmpty(numberLabel)) {
          views.labelView.setText(numberLabel);
          views.labelView.setVisibility(View.VISIBLE);

          // Zero out the numberView's left margin (see below)
          ViewGroup.MarginLayoutParams numberLP =
              (ViewGroup.MarginLayoutParams) views.numberView.getLayoutParams();
          numberLP.leftMargin = 0;
          views.numberView.setLayoutParams(numberLP);
        } else {
          // There's nothing to display in views.labelView, so hide it.
          // We can't set it to View.GONE, since it's the anchor for
          // numberView in the RelativeLayout, so make it INVISIBLE.
          //   Also, we need to manually *subtract* some left margin from
          // numberView to compensate for the right margin built in to
          // labelView (otherwise the number will be indented by a very
          // slight amount).
          //   TODO: a cleaner fix would be to contain both the label and
          // number inside a LinearLayout, and then set labelView *and*
          // its padding to GONE when there's no label to display.
          views.labelView.setText(null);
          views.labelView.setVisibility(View.INVISIBLE);

          ViewGroup.MarginLayoutParams labelLP =
              (ViewGroup.MarginLayoutParams) views.labelView.getLayoutParams();
          ViewGroup.MarginLayoutParams numberLP =
              (ViewGroup.MarginLayoutParams) views.numberView.getLayoutParams();
          // Equivalent to setting android:layout_marginLeft in XML
          numberLP.leftMargin = -labelLP.rightMargin;
          views.numberView.setLayoutParams(numberLP);
        }
      } else {
        if (number.equals(CallerInfo.UNKNOWN_NUMBER)) {
          number = getString(R.string.unknown);
          views.callView.setVisibility(View.INVISIBLE);
        } else if (number.equals(CallerInfo.PRIVATE_NUMBER)) {
          number = getString(R.string.private_num);
          views.callView.setVisibility(View.INVISIBLE);
        } else if (number.equals(CallerInfo.PAYPHONE_NUMBER)) {
          number = getString(R.string.payphone);
        } else if (PhoneNumberUtils.extractNetworkPortion(number).equals(mVoiceMailNumber)) {
          number = getString(R.string.voicemail);
        } else {
          // Just a raw number, and no cache, so format it nicely
          number = formatPhoneNumber(number);
        }

        views.line1View.setText(number);
        views.numberView.setVisibility(View.GONE);
        views.labelView.setVisibility(View.GONE);
      }

      long date = c.getLong(DATE_COLUMN_INDEX);

      // Set the date/time field by mixing relative and absolute times.
      int flags = DateUtils.FORMAT_ABBREV_RELATIVE;

      views.dateView.setText(
          DateUtils.getRelativeTimeSpanString(
              date, System.currentTimeMillis(), DateUtils.MINUTE_IN_MILLIS, flags));

      if (views.iconView != null) {
        int type = c.getInt(CALL_TYPE_COLUMN_INDEX);
        // Set the icon
        switch (type) {
          case Calls.INCOMING_TYPE:
            views.iconView.setImageDrawable(mDrawableIncoming);
            break;

          case Calls.OUTGOING_TYPE:
            views.iconView.setImageDrawable(mDrawableOutgoing);
            break;

          case Calls.MISSED_TYPE:
            views.iconView.setImageDrawable(mDrawableMissed);
            break;
        }
      }

      // Listen for the first draw
      if (mPreDrawListener == null) {
        mFirst = true;
        mPreDrawListener = this;
        view.getViewTreeObserver().addOnPreDrawListener(this);
      }
    }
Exemplo n.º 6
0
  public void refreshSubActions(Context context) {
    subActions.clear();

    subActions.add(ActionManager.getAction(InternalActions.SpeakerphoneAction.id));

    subActions.add(
        new Action() {

          @Override
          public String getName() {
            return "Voicemail";
          }

          @Override
          public String bulletIcon() {
            return "bullet_circle.bmp";
          }

          @Override
          public int performAction(Context context) {
            Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse("voicemail:"));
            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            context.startActivity(intent);
            return InternalApp.BUTTON_USED;
          }
        });

    final String[] projection =
        new String[] {
          ContactsContract.Contacts._ID,
          ContactsContract.Contacts.DISPLAY_NAME,
          ContactsContract.Contacts.HAS_PHONE_NUMBER,
        };

    Cursor people =
        context
            .getContentResolver()
            .query(
                ContactsContract.Contacts.CONTENT_URI,
                projection,
                "starred=?",
                new String[] {"1"},
                ContactsContract.Contacts.TIMES_CONTACTED + " DESC");

    while (people.moveToNext()) {
      int idFieldIndex = people.getColumnIndex(ContactsContract.Contacts._ID);
      final String id = people.getString(idFieldIndex);

      int nameFieldIndex = people.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME);
      final String contact = people.getString(nameFieldIndex);

      int hasNumberFieldIndex = people.getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NUMBER);
      if (Integer.parseInt(people.getString(hasNumberFieldIndex)) > 0) {

        Cursor personNumbers =
            context
                .getContentResolver()
                .query(Phone.CONTENT_URI, null, Phone.CONTACT_ID + "=?", new String[] {id}, null);
        if (personNumbers == null) continue;

        ContainerAction personContainer = null;
        String prefix = contact + " ";
        if (personNumbers.getCount() > 1) {
          personContainer =
              new ContainerAction() {
                public String getName() {
                  return contact;
                }
              };
          subActions.add(personContainer);
          prefix = "";
        }
        final String namePrefix = prefix;

        while (personNumbers.moveToNext()) {

          int phoneFieldIndex = personNumbers.getColumnIndex(Phone.DATA);
          final String number = personNumbers.getString(phoneFieldIndex);

          int typeFieldIndex = personNumbers.getColumnIndex(Phone.TYPE);
          final String type =
              (String)
                  Phone.getTypeLabel(
                      context.getResources(), personNumbers.getInt(typeFieldIndex), "");

          Action numberEntry =
              new Action() {

                String title = namePrefix + type + "\n" + number;
                String uri = "tel:" + number;

                @Override
                public String getName() {
                  return title;
                }

                @Override
                public String bulletIcon() {
                  return "bullet_circle.bmp";
                }

                @Override
                public int performAction(Context context) {
                  Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse(uri));
                  intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                  context.startActivity(intent);
                  return InternalApp.BUTTON_USED;
                }
              };

          if (personContainer != null) {
            personContainer.addSubAction(numberEntry);
          } else {
            subActions.add(numberEntry);
          }
        }
      }
    }

    people.close();
  }
Exemplo n.º 7
0
 @Override
 public CharSequence getTypeLabel(Resources res, int type, CharSequence label) {
   return Phone.getTypeLabel(res, type, label);
 }
Exemplo n.º 8
0
  /**
   * getCallerInfo given a Cursor.
   *
   * @param context the context used to retrieve string constants
   * @param contactRef the URI to attach to this CallerInfo object
   * @param cursor the first object in the cursor is used to build the CallerInfo object.
   * @return the CallerInfo which contains the caller id for the given number. The returned
   *     CallerInfo is null if no number is supplied.
   */
  public static CallerInfo getCallerInfo(Context context, Uri contactRef, Cursor cursor) {
    CallerInfo info = new CallerInfo();
    info.photoResource = 0;
    info.phoneLabel = null;
    info.numberType = 0;
    info.numberLabel = null;
    info.cachedPhoto = null;
    info.isCachedPhotoCurrent = false;
    info.contactExists = false;

    if (VDBG) Rlog.v(TAG, "getCallerInfo() based on cursor...");

    if (cursor != null) {
      if (cursor.moveToFirst()) {
        // TODO: photo_id is always available but not taken
        // care of here. Maybe we should store it in the
        // CallerInfo object as well.

        int columnIndex;

        // Look for the name
        columnIndex = cursor.getColumnIndex(PhoneLookup.DISPLAY_NAME);
        if (columnIndex != -1) {
          info.name = cursor.getString(columnIndex);
        }

        // Look for the number
        columnIndex = cursor.getColumnIndex(PhoneLookup.NUMBER);
        if (columnIndex != -1) {
          info.phoneNumber = cursor.getString(columnIndex);
        }

        // Look for the normalized number
        columnIndex = cursor.getColumnIndex(PhoneLookup.NORMALIZED_NUMBER);
        if (columnIndex != -1) {
          info.normalizedNumber = cursor.getString(columnIndex);
        }

        // Look for the label/type combo
        columnIndex = cursor.getColumnIndex(PhoneLookup.LABEL);
        if (columnIndex != -1) {
          int typeColumnIndex = cursor.getColumnIndex(PhoneLookup.TYPE);
          if (typeColumnIndex != -1) {
            info.numberType = cursor.getInt(typeColumnIndex);
            info.numberLabel = cursor.getString(columnIndex);
            info.phoneLabel =
                Phone.getDisplayLabel(context, info.numberType, info.numberLabel).toString();
          }
        }

        // Look for the person_id.
        columnIndex = getColumnIndexForPersonId(contactRef, cursor);
        if (columnIndex != -1) {
          final long contactId = cursor.getLong(columnIndex);
          if (contactId != 0 && !Contacts.isEnterpriseContactId(contactId)) {
            info.contactIdOrZero = contactId;
            if (VDBG) {
              Rlog.v(TAG, "==> got info.contactIdOrZero: " + info.contactIdOrZero);
            }
          }
        } else {
          // No valid columnIndex, so we can't look up person_id.
          Rlog.w(TAG, "Couldn't find contact_id column for " + contactRef);
          // Watch out: this means that anything that depends on
          // person_id will be broken (like contact photo lookups in
          // the in-call UI, for example.)
        }

        // Contact lookupKey
        columnIndex = cursor.getColumnIndex(PhoneLookup.LOOKUP_KEY);
        if (columnIndex != -1) {
          info.lookupKey = cursor.getString(columnIndex);
        }

        // Display photo URI.
        columnIndex = cursor.getColumnIndex(PhoneLookup.PHOTO_URI);
        if ((columnIndex != -1) && (cursor.getString(columnIndex) != null)) {
          info.contactDisplayPhotoUri = Uri.parse(cursor.getString(columnIndex));
        } else {
          info.contactDisplayPhotoUri = null;
        }

        // look for the custom ringtone, create from the string stored
        // in the database.
        columnIndex = cursor.getColumnIndex(PhoneLookup.CUSTOM_RINGTONE);
        if ((columnIndex != -1) && (cursor.getString(columnIndex) != null)) {
          info.contactRingtoneUri = Uri.parse(cursor.getString(columnIndex));
        } else {
          info.contactRingtoneUri = null;
        }

        // look for the send to voicemail flag, set it to true only
        // under certain circumstances.
        columnIndex = cursor.getColumnIndex(PhoneLookup.SEND_TO_VOICEMAIL);
        info.shouldSendToVoicemail = (columnIndex != -1) && ((cursor.getInt(columnIndex)) == 1);
        info.contactExists = true;
      }
      cursor.close();
      cursor = null;
    }

    info.needUpdate = false;
    info.name = normalize(info.name);
    info.contactRefUri = contactRef;

    return info;
  }
 /**
  * Default return Phone.getTypeLabel(res, type, label);
  *
  * @param res
  * @param type
  * @param label
  * @param slotId
  * @return
  */
 public CharSequence getTypeLabel(
     Resources res, int type, CharSequence label, int slotId, String commd) {
   return Phone.getTypeLabel(res, type, label);
 }