/** Mark this entire object deleted, including any {@link ValuesDelta}. */
 public void markDeleted() {
   this.mValues.markDeleted();
   for (ArrayList<ValuesDelta> mimeEntries : mEntries.values()) {
     for (ValuesDelta child : mimeEntries) {
       child.markDeleted();
     }
   }
 }
 /**
  * Build an {@link RawContactDelta} using the given {@link RawContact} as a starting point; the
  * "before" snapshot.
  */
 public static RawContactDelta fromBefore(RawContact before) {
   final RawContactDelta rawContactDelta = new RawContactDelta();
   rawContactDelta.mValues = ValuesDelta.fromBefore(before.getValues());
   rawContactDelta.mValues.setIdColumn(RawContacts._ID);
   for (final ContentValues values : before.getContentValues()) {
     rawContactDelta.addEntry(ValuesDelta.fromBefore(values));
   }
   return rawContactDelta;
 }
 private boolean containsEntry(ValuesDelta entry) {
   for (ArrayList<ValuesDelta> mimeEntries : mEntries.values()) {
     for (ValuesDelta child : mimeEntries) {
       // Contained if we find any child that matches
       if (child.equals(entry)) return true;
     }
   }
   return false;
 }
 /** Tests whether the given item has no changes (so it exists in the database) but is empty */
 private boolean isEmptyNoop(ValuesDelta item) {
   if (!item.isNoop()) return false;
   final int fieldCount = mKind.fieldList.size();
   for (int i = 0; i < fieldCount; i++) {
     final String column = mKind.fieldList.get(i).column;
     final String value = item.getAsString(column);
     if (!TextUtils.isEmpty(value)) return false;
   }
   return true;
 }
 public ArrayList<ContentValues> getContentValues() {
   ArrayList<ContentValues> values = Lists.newArrayList();
   for (ArrayList<ValuesDelta> mimeEntries : mEntries.values()) {
     for (ValuesDelta entry : mimeEntries) {
       if (!entry.isDelete()) {
         values.add(entry.getCompleteValues());
       }
     }
   }
   return values;
 }
  public int getMimeEntriesCount(String mimeType, boolean onlyVisible) {
    final ArrayList<ValuesDelta> mimeEntries = getMimeEntries(mimeType);
    if (mimeEntries == null) return 0;

    int count = 0;
    for (ValuesDelta child : mimeEntries) {
      // Skip deleted items when requesting only visible
      if (onlyVisible && !child.isVisible()) continue;
      count++;
    }
    return count;
  }
  /**
   * Get the {@link ValuesDelta} child marked as {@link Data#IS_PRIMARY}, which may return null when
   * no entry exists.
   */
  public ValuesDelta getPrimaryEntry(String mimeType) {
    final ArrayList<ValuesDelta> mimeEntries = getMimeEntries(mimeType, false);
    if (mimeEntries == null) return null;

    for (ValuesDelta entry : mimeEntries) {
      if (entry.isPrimary()) {
        return entry;
      }
    }

    // When no direct primary, return something
    return mimeEntries.size() > 0 ? mimeEntries.get(0) : null;
  }
 private Builder buildAssertHelper() {
   final boolean isContactInsert = mValues.isInsert();
   ContentProviderOperation.Builder builder = null;
   if (!isContactInsert) {
     // Assert version is consistent while persisting changes
     final Long beforeId = mValues.getId();
     final Long beforeVersion = mValues.getAsLong(RawContacts.VERSION);
     if (beforeId == null || beforeVersion == null) return builder;
     builder = ContentProviderOperation.newAssertQuery(mContactsQueryUri);
     builder.withSelection(RawContacts._ID + "=" + beforeId, null);
     builder.withValue(RawContacts.VERSION, beforeVersion);
   }
   return builder;
 }
  /** Find entry with the given {@link BaseColumns#_ID} value. */
  public ValuesDelta getEntry(Long childId) {
    if (childId == null) {
      // Requesting an "insert" entry, which has no "before"
      return null;
    }

    // Search all children for requested entry
    for (ArrayList<ValuesDelta> mimeEntries : mEntries.values()) {
      for (ValuesDelta entry : mimeEntries) {
        if (childId.equals(entry.getId())) {
          return entry;
        }
      }
    }
    return null;
  }
  /**
   * Prepare this editor using the given {@link DataKind} for defining structure and {@link
   * ValuesDelta} describing the content to edit.
   */
  @Override
  public void setValues(
      DataKind kind,
      ValuesDelta entry,
      RawContactDelta state,
      boolean readOnly,
      ViewIdGenerator vig) {
    mKind = kind;
    mEntry = entry;
    mState = state;
    mReadOnly = readOnly;
    mViewIdGenerator = vig;
    setId(vig.getId(state, kind, entry, ViewIdGenerator.NO_VIEW_INDEX));

    if (!entry.isVisible()) {
      // Hide ourselves entirely if deleted
      setVisibility(View.GONE);
      return;
    }
    setVisibility(View.VISIBLE);

    // Display label selector if multiple types available
    final boolean hasTypes = RawContactModifier.hasEditTypes(kind);
    setupLabelButton(hasTypes);
    mLabel.setEnabled(!readOnly && isEnabled());
    if (hasTypes) {
      mType = RawContactModifier.getCurrentType(entry, kind);
      rebuildLabel();
    }
  }
  @Override
  public void deleteEditor() {
    // Keep around in model, but mark as deleted
    mEntry.markDeleted();

    // Remove the view
    EditorAnimator.getInstance().removeEditorView(this);
  }
 protected boolean isFieldChanged(String column, String value) {
   final String dbValue = mEntry.getAsString(column);
   // nullable fields (e.g. Middle Name) are usually represented as empty columns,
   // so lets treat null and empty space equivalently here
   final String dbValueNoNull = dbValue == null ? "" : dbValue;
   final String valueNoNull = value == null ? "" : value;
   return !TextUtils.equals(dbValueNoNull, valueNoNull);
 }
  /** Build editors for all current {@link #mState} rows. */
  public void rebuildFromState() {
    // Remove any existing editors
    mEditors.removeAllViews();

    // Check if we are displaying anything here
    boolean hasEntries = mState.hasMimeEntries(mKind.mimeType);

    if (hasEntries) {
      for (ValuesDelta entry : mState.getMimeEntries(mKind.mimeType)) {
        // Skip entries that aren't visible
        if (!entry.isVisible()) continue;
        if (isEmptyNoop(entry)) continue;

        createEditorView(entry);
      }
    }
  }
  private boolean hasMembership(long groupId) {
    if (groupId == mDefaultGroupId && mState.isContactInsert()) {
      return true;
    }

    ArrayList<ValuesDelta> entries = mState.getMimeEntries(GroupMembership.CONTENT_ITEM_TYPE);
    if (entries != null) {
      for (ValuesDelta values : entries) {
        if (!values.isDelete()) {
          Long id = values.getGroupRowId();
          if (id != null && id == groupId) {
            return true;
          }
        }
      }
    }
    return false;
  }
Ejemplo n.º 15
0
 @Override
 public String toString() {
   final StringBuilder builder = new StringBuilder();
   builder.append("\n(");
   builder.append("Uri=");
   builder.append(mContactsQueryUri);
   builder.append(", Values=");
   builder.append(mValues != null ? mValues.toString() : "null");
   builder.append(", Entries={");
   for (ArrayList<ValuesDelta> mimeEntries : mEntries.values()) {
     for (ValuesDelta child : mimeEntries) {
       builder.append("\n\t");
       child.toString(builder);
     }
   }
   builder.append("\n})\n");
   return builder.toString();
 }
Ejemplo n.º 16
0
  /**
   * Returns the super-primary entry for the given mime type
   *
   * @param forceSelection if true, will try to return some value even if a super-primary doesn't
   *     exist (may be a primary, or just a random item
   * @return
   */
  @NeededForTesting
  public ValuesDelta getSuperPrimaryEntry(String mimeType, boolean forceSelection) {
    final ArrayList<ValuesDelta> mimeEntries = getMimeEntries(mimeType, false);
    if (mimeEntries == null) return null;

    ValuesDelta primary = null;
    for (ValuesDelta entry : mimeEntries) {
      if (entry.isSuperPrimary()) {
        return entry;
      } else if (entry.isPrimary()) {
        primary = entry;
      }
    }

    if (!forceSelection) {
      return null;
    }

    // When no direct super primary, return something
    if (primary != null) {
      return primary;
    }
    return mimeEntries.size() > 0 ? mimeEntries.get(0) : null;
  }
  protected void onTypeSelectionChange(int position) {
    EditType selected = mEditTypeAdapter.getItem(position);
    // See if the selection has in fact changed
    if (mEditTypeAdapter.hasCustomSelection() && selected == CUSTOM_SELECTION) {
      return;
    }

    if (mType == selected && mType.customColumn == null) {
      return;
    }

    if (selected.customColumn != null) {
      showDialog(DIALOG_ID_CUSTOM);
    } else {
      // User picked type, and we're sure it's ok to actually write the entry.
      mType = selected;
      mEntry.put(mKind.typeColumn, mType.rawValue);
      rebuildLabel();
      requestFocusForFirstEditField();
      onLabelRebuilt();
    }
  }
  private static String getMapKey(
      RawContactDelta entity, DataKind kind, ValuesDelta values, int viewIndex) {
    sWorkStringBuilder.setLength(0);
    if (entity != null) {
      sWorkStringBuilder.append(entity.getValues().getId());

      if (kind != null) {
        sWorkStringBuilder.append(KEY_SEPARATOR);
        sWorkStringBuilder.append(kind.mimeType);

        if (values != null) {
          sWorkStringBuilder.append(KEY_SEPARATOR);
          sWorkStringBuilder.append(values.getId());

          if (viewIndex != NO_VIEW_INDEX) {
            sWorkStringBuilder.append(KEY_SEPARATOR);
            sWorkStringBuilder.append(viewIndex);
          }
        }
      }
    }
    return sWorkStringBuilder.toString();
  }
  @Override
  public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
    ListView list = (ListView) parent;
    int count = mAdapter.getCount();

    if (list.isItemChecked(count - 1)) {
      list.setItemChecked(count - 1, false);
      createNewGroup();
      return;
    }

    for (int i = 0; i < count; i++) {
      mAdapter.getItem(i).setChecked(list.isItemChecked(i));
    }

    // First remove the memberships that have been unchecked
    ArrayList<ValuesDelta> entries = mState.getMimeEntries(GroupMembership.CONTENT_ITEM_TYPE);
    if (entries != null) {
      for (ValuesDelta entry : entries) {
        if (!entry.isDelete()) {
          Long groupId = entry.getGroupRowId();
          if (groupId != null
              && groupId != mFavoritesGroupId
              && (groupId != mDefaultGroupId || mDefaultGroupVisible)
              && !isGroupChecked(groupId)) {
            entry.markDeleted();
          }
        }
      }
    }

    // Now add the newly selected items
    for (int i = 0; i < count; i++) {
      GroupSelectionItem item = mAdapter.getItem(i);
      long groupId = item.getGroupId();
      if (item.isChecked() && !hasMembership(groupId)) {
        ValuesDelta entry = RawContactModifier.insertChild(mState, mKind);
        entry.setGroupRowId(groupId);
      }
    }

    updateView();
  }
Ejemplo n.º 20
0
  /**
   * Merge the "after" values from the given {@link RawContactDelta} onto the "before" state
   * represented by this {@link RawContactDelta}, discarding any existing "after" states. This is
   * typically used when re-parenting changes onto an updated {@link Entity}.
   */
  public static RawContactDelta mergeAfter(RawContactDelta local, RawContactDelta remote) {
    // Bail early if trying to merge delete with missing local
    final ValuesDelta remoteValues = remote.mValues;
    if (local == null && (remoteValues.isDelete() || remoteValues.isTransient())) return null;

    // Create local version if none exists yet
    if (local == null) local = new RawContactDelta();

    if (LOGV) {
      final Long localVersion =
          (local.mValues == null) ? null : local.mValues.getAsLong(RawContacts.VERSION);
      final Long remoteVersion = remote.mValues.getAsLong(RawContacts.VERSION);
      Log.d(TAG, "Re-parenting from original version " + remoteVersion + " to " + localVersion);
    }

    // Create values if needed, and merge "after" changes
    local.mValues = ValuesDelta.mergeAfter(local.mValues, remote.mValues);

    // Find matching local entry for each remote values, or create
    for (ArrayList<ValuesDelta> mimeEntries : remote.mEntries.values()) {
      for (ValuesDelta remoteEntry : mimeEntries) {
        final Long childId = remoteEntry.getId();

        // Find or create local match and merge
        final ValuesDelta localEntry = local.getEntry(childId);
        final ValuesDelta merged = ValuesDelta.mergeAfter(localEntry, remoteEntry);

        if (localEntry == null && merged != null) {
          // No local entry before, so insert
          local.addEntry(merged);
        }
      }
    }

    return local;
  }
  @Override
  public void setValues(
      DataKind kind,
      ValuesDelta entry,
      RawContactDelta state,
      boolean readOnly,
      ViewIdGenerator vig) {
    super.setValues(kind, entry, state, readOnly, vig);
    // Remove edit texts that we currently have
    if (mFieldEditTexts != null) {
      for (EditText fieldEditText : mFieldEditTexts) {
        mFields.removeView(fieldEditText);
      }
    }
    boolean hidePossible = false;

    int fieldCount = kind.fieldList.size();
    mFieldEditTexts = new EditText[fieldCount];
    for (int index = 0; index < fieldCount; index++) {
      final EditField field = kind.fieldList.get(index);
      final EditText fieldView = new EditText(mContext);
      fieldView.setLayoutParams(
          new LinearLayout.LayoutParams(
              LayoutParams.MATCH_PARENT,
              field.isMultiLine() ? LayoutParams.WRAP_CONTENT : mMinFieldHeight));
      // Set either a minimum line requirement or a minimum height (because {@link TextView}
      // only takes one or the other at a single time).
      if (field.minLines != 0) {
        fieldView.setMinLines(field.minLines);
      } else {
        fieldView.setMinHeight(mMinFieldHeight);
      }
      fieldView.setTextAppearance(getContext(), android.R.style.TextAppearance_Medium);
      fieldView.setGravity(Gravity.TOP);
      mFieldEditTexts[index] = fieldView;
      fieldView.setId(vig.getId(state, kind, entry, index));
      if (field.titleRes > 0) {
        fieldView.setHint(field.titleRes);
      }
      int inputType = field.inputType;
      fieldView.setInputType(inputType);
      if (inputType == InputType.TYPE_CLASS_PHONE) {
        PhoneNumberFormatter.setPhoneNumberFormattingTextWatcher(mContext, fieldView);
        fieldView.setTextDirection(View.TEXT_DIRECTION_LTR);
      }

      // Show the "next" button in IME to navigate between text fields
      // TODO: Still need to properly navigate to/from sections without text fields,
      // See Bug: 5713510
      fieldView.setImeOptions(EditorInfo.IME_ACTION_NEXT);

      // Read current value from state
      final String column = field.column;
      final String value = entry.getAsString(column);
      fieldView.setText(value);

      // Show the delete button if we have a non-null value
      setDeleteButtonVisible(value != null);

      // Prepare listener for writing changes
      fieldView.addTextChangedListener(
          new TextWatcher() {
            @Override
            public void afterTextChanged(Editable s) {
              // Trigger event for newly changed value
              onFieldChanged(column, s.toString());
            }

            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {}

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {}
          });

      fieldView.setEnabled(isEnabled() && !readOnly);

      if (field.shortForm) {
        hidePossible = true;
        mHasShortAndLongForms = true;
        fieldView.setVisibility(mHideOptional ? View.VISIBLE : View.GONE);
      } else if (field.longForm) {
        hidePossible = true;
        mHasShortAndLongForms = true;
        fieldView.setVisibility(mHideOptional ? View.GONE : View.VISIBLE);
      } else {
        // Hide field when empty and optional value
        final boolean couldHide = (!ContactsUtils.isGraphic(value) && field.optional);
        final boolean willHide = (mHideOptional && couldHide);
        fieldView.setVisibility(willHide ? View.GONE : View.VISIBLE);
        hidePossible = hidePossible || couldHide;
      }

      mFields.addView(fieldView);
    }

    // When hiding fields, place expandable
    setupExpansionView(hidePossible, mHideOptional);
    mExpansionView.setEnabled(!readOnly && isEnabled());
  }
 protected void saveValue(String column, String value) {
   mEntry.put(column, value);
 }
Ejemplo n.º 23
0
 public boolean isContactInsert() {
   return mValues.isInsert();
 }
Ejemplo n.º 24
0
 public ValuesDelta addEntry(ValuesDelta entry) {
   final String mimeType = entry.getMimetype();
   getMimeEntries(mimeType, true).add(entry);
   return entry;
 }
Ejemplo n.º 25
0
  /**
   * For compatibility purpose, this method is copied from {@link #buildDiff} and takes an ArrayList
   * of CPOWrapper as parameter.
   */
  public void buildDiffWrapper(ArrayList<CPOWrapper> buildInto) {
    final int firstIndex = buildInto.size();

    final boolean isContactInsert = mValues.isInsert();
    final boolean isContactDelete = mValues.isDelete();
    final boolean isContactUpdate = !isContactInsert && !isContactDelete;

    final Long beforeId = mValues.getId();

    if (isContactInsert) {
      // TODO: for now simply disabling aggregation when a new contact is
      // created on the phone.  In the future, will show aggregation suggestions
      // after saving the contact.
      mValues.put(RawContacts.AGGREGATION_MODE, RawContacts.AGGREGATION_MODE_SUSPENDED);
    }

    // Build possible operation at Contact level
    BuilderWrapper bw = mValues.buildDiffWrapper(mContactsQueryUri);
    possibleAddWrapper(buildInto, bw);

    // Build operations for all children
    for (ArrayList<ValuesDelta> mimeEntries : mEntries.values()) {
      for (ValuesDelta child : mimeEntries) {
        // Ignore children if parent was deleted
        if (isContactDelete) continue;

        // Use the profile data URI if the contact is the profile.
        if (mContactsQueryUri.equals(Profile.CONTENT_RAW_CONTACTS_URI)) {
          bw =
              child.buildDiffWrapper(
                  Uri.withAppendedPath(Profile.CONTENT_URI, RawContacts.Data.CONTENT_DIRECTORY));
        } else {
          bw = child.buildDiffWrapper(Data.CONTENT_URI);
        }

        if (child.isInsert()) {
          if (isContactInsert) {
            // Parent is brand new insert, so back-reference _id
            bw.getBuilder().withValueBackReference(Data.RAW_CONTACT_ID, firstIndex);
          } else {
            // Inserting under existing, so fill with known _id
            bw.getBuilder().withValue(Data.RAW_CONTACT_ID, beforeId);
          }
        } else if (isContactInsert && bw != null && bw.getBuilder() != null) {
          // Child must be insert when Contact insert
          throw new IllegalArgumentException("When parent insert, child must be also");
        }
        possibleAddWrapper(buildInto, bw);
      }
    }

    final boolean addedOperations = buildInto.size() > firstIndex;
    if (addedOperations && isContactUpdate) {
      // Suspend aggregation while persisting updates
      Builder builder = buildSetAggregationMode(beforeId, RawContacts.AGGREGATION_MODE_SUSPENDED);
      buildInto.add(firstIndex, new CPOWrapper(builder.build(), CompatUtils.TYPE_UPDATE));

      // Restore aggregation mode as last operation
      builder = buildSetAggregationMode(beforeId, RawContacts.AGGREGATION_MODE_DEFAULT);
      buildInto.add(new CPOWrapper(builder.build(), CompatUtils.TYPE_UPDATE));
    } else if (isContactInsert) {
      // Restore aggregation mode as last operation
      Builder builder = ContentProviderOperation.newUpdate(mContactsQueryUri);
      builder.withValue(RawContacts.AGGREGATION_MODE, RawContacts.AGGREGATION_MODE_DEFAULT);
      builder.withSelection(RawContacts._ID + "=?", new String[1]);
      builder.withSelectionBackReference(0, firstIndex);
      buildInto.add(new CPOWrapper(builder.build(), CompatUtils.TYPE_UPDATE));
    }
  }