Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2015 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | package com.android.contacts.editor; |
| 18 | |
| 19 | import android.content.Context; |
Walter Jang | f10ca15 | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 20 | import android.database.Cursor; |
Walter Jang | 4f5594a | 2015-10-06 18:40:31 -0700 | [diff] [blame] | 21 | import android.provider.ContactsContract.CommonDataKinds.Event; |
Walter Jang | f10ca15 | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 22 | import android.provider.ContactsContract.CommonDataKinds.GroupMembership; |
Walter Jang | 4f5594a | 2015-10-06 18:40:31 -0700 | [diff] [blame] | 23 | import android.provider.ContactsContract.CommonDataKinds.Nickname; |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 24 | import android.provider.ContactsContract.CommonDataKinds.StructuredName; |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 25 | import android.util.AttributeSet; |
| 26 | import android.view.LayoutInflater; |
| 27 | import android.view.View; |
| 28 | import android.view.ViewGroup; |
| 29 | import android.widget.ImageView; |
| 30 | import android.widget.LinearLayout; |
Walter Jang | 1ee24ed | 2015-09-25 17:49:14 -0700 | [diff] [blame] | 31 | import android.widget.TextView; |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 32 | |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 33 | import com.android.contacts.R; |
Gary Mai | 69c182a | 2016-12-05 13:07:03 -0800 | [diff] [blame] | 34 | import com.android.contacts.model.RawContactDelta; |
| 35 | import com.android.contacts.model.RawContactModifier; |
| 36 | import com.android.contacts.model.ValuesDelta; |
| 37 | import com.android.contacts.model.account.AccountType; |
| 38 | import com.android.contacts.model.dataitem.DataKind; |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 39 | |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 40 | import java.util.ArrayList; |
| 41 | import java.util.List; |
| 42 | |
| 43 | /** |
Gary Mai | 65971d0 | 2016-09-15 15:00:16 -0700 | [diff] [blame] | 44 | * Custom view for an entire section of data as segmented by |
| 45 | * {@link DataKind} around a {@link Data#MIMETYPE}. This view shows a |
| 46 | * section header and a trigger for adding new {@link Data} rows. |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 47 | */ |
Gary Mai | 363af60 | 2016-09-28 10:01:23 -0700 | [diff] [blame] | 48 | public class KindSectionView extends LinearLayout { |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 49 | |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 50 | /** |
| 51 | * Marks a name as super primary when it is changed. |
| 52 | * |
| 53 | * This is for the case when two or more raw contacts with names are joined where neither is |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 54 | * marked as super primary. |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 55 | */ |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 56 | private static final class StructuredNameEditorListener implements Editor.EditorListener { |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 57 | |
| 58 | private final ValuesDelta mValuesDelta; |
| 59 | private final long mRawContactId; |
Gary Mai | 363af60 | 2016-09-28 10:01:23 -0700 | [diff] [blame] | 60 | private final RawContactEditorView.Listener mListener; |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 61 | |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 62 | public StructuredNameEditorListener(ValuesDelta valuesDelta, long rawContactId, |
Gary Mai | 363af60 | 2016-09-28 10:01:23 -0700 | [diff] [blame] | 63 | RawContactEditorView.Listener listener) { |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 64 | mValuesDelta = valuesDelta; |
| 65 | mRawContactId = rawContactId; |
| 66 | mListener = listener; |
| 67 | } |
| 68 | |
| 69 | @Override |
| 70 | public void onRequest(int request) { |
| 71 | if (request == Editor.EditorListener.FIELD_CHANGED) { |
| 72 | mValuesDelta.setSuperPrimary(true); |
| 73 | if (mListener != null) { |
| 74 | mListener.onNameFieldChanged(mRawContactId, mValuesDelta); |
| 75 | } |
| 76 | } else if (request == Editor.EditorListener.FIELD_TURNED_EMPTY) { |
| 77 | mValuesDelta.setSuperPrimary(false); |
| 78 | } |
| 79 | } |
| 80 | |
| 81 | @Override |
| 82 | public void onDeleteRequested(Editor editor) { |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 83 | editor.clearAllFields(); |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 84 | } |
| 85 | } |
| 86 | |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 87 | /** |
| 88 | * Clears fields when deletes are requested (on phonetic and nickename fields); |
| 89 | * does not change the number of editors. |
| 90 | */ |
| 91 | private static final class OtherNameKindEditorListener implements Editor.EditorListener { |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 92 | |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 93 | @Override |
| 94 | public void onRequest(int request) { |
| 95 | } |
| 96 | |
| 97 | @Override |
| 98 | public void onDeleteRequested(Editor editor) { |
| 99 | editor.clearAllFields(); |
| 100 | } |
| 101 | } |
| 102 | |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 103 | /** |
| 104 | * Updates empty fields when fields are deleted or turns empty. |
| 105 | * Whether a new empty editor is added is controlled by {@link #setShowOneEmptyEditor} and |
| 106 | * {@link #setHideWhenEmpty}. |
| 107 | */ |
Wenyi Wang | 2da5d2f | 2015-09-29 22:15:38 -0700 | [diff] [blame] | 108 | private class NonNameEditorListener implements Editor.EditorListener { |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 109 | |
| 110 | @Override |
| 111 | public void onRequest(int request) { |
| 112 | // If a field has become empty or non-empty, then check if another row |
| 113 | // can be added dynamically. |
| 114 | if (request == FIELD_TURNED_EMPTY || request == FIELD_TURNED_NON_EMPTY) { |
| 115 | updateEmptyEditors(/* shouldAnimate = */ true); |
| 116 | } |
| 117 | } |
| 118 | |
| 119 | @Override |
| 120 | public void onDeleteRequested(Editor editor) { |
| 121 | if (mShowOneEmptyEditor && mEditors.getChildCount() == 1) { |
| 122 | // If there is only 1 editor in the section, then don't allow the user to |
| 123 | // delete it. Just clear the fields in the editor. |
| 124 | editor.clearAllFields(); |
| 125 | } else { |
| 126 | editor.deleteEditor(); |
| 127 | } |
| 128 | } |
| 129 | } |
| 130 | |
Wenyi Wang | 2da5d2f | 2015-09-29 22:15:38 -0700 | [diff] [blame] | 131 | private class EventEditorListener extends NonNameEditorListener { |
| 132 | |
| 133 | @Override |
| 134 | public void onRequest(int request) { |
| 135 | super.onRequest(request); |
| 136 | } |
| 137 | |
| 138 | @Override |
| 139 | public void onDeleteRequested(Editor editor) { |
| 140 | if (editor instanceof EventFieldEditorView){ |
| 141 | final EventFieldEditorView delView = (EventFieldEditorView) editor; |
| 142 | if (delView.isBirthdayType() && mEditors.getChildCount() > 1) { |
| 143 | final EventFieldEditorView bottomView = (EventFieldEditorView) mEditors |
| 144 | .getChildAt(mEditors.getChildCount() - 1); |
| 145 | bottomView.restoreBirthday(); |
| 146 | } |
| 147 | } |
| 148 | super.onDeleteRequested(editor); |
| 149 | } |
| 150 | } |
| 151 | |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 152 | private KindSectionData mKindSectionData; |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 153 | private ViewIdGenerator mViewIdGenerator; |
Gary Mai | 363af60 | 2016-09-28 10:01:23 -0700 | [diff] [blame] | 154 | private RawContactEditorView.Listener mListener; |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 155 | |
Walter Jang | 45b86d5 | 2015-10-15 15:23:16 -0700 | [diff] [blame] | 156 | private boolean mIsUserProfile; |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 157 | private boolean mShowOneEmptyEditor = false; |
| 158 | private boolean mHideIfEmpty = true; |
| 159 | |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 160 | private LayoutInflater mLayoutInflater; |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 161 | private ViewGroup mEditors; |
| 162 | private ImageView mIcon; |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 163 | |
Gary Mai | 363af60 | 2016-09-28 10:01:23 -0700 | [diff] [blame] | 164 | public KindSectionView(Context context) { |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 165 | this(context, /* attrs =*/ null); |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 166 | } |
| 167 | |
Gary Mai | 363af60 | 2016-09-28 10:01:23 -0700 | [diff] [blame] | 168 | public KindSectionView(Context context, AttributeSet attrs) { |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 169 | super(context, attrs); |
| 170 | } |
| 171 | |
| 172 | @Override |
| 173 | public void setEnabled(boolean enabled) { |
| 174 | super.setEnabled(enabled); |
| 175 | if (mEditors != null) { |
| 176 | int childCount = mEditors.getChildCount(); |
| 177 | for (int i = 0; i < childCount; i++) { |
| 178 | mEditors.getChildAt(i).setEnabled(enabled); |
| 179 | } |
| 180 | } |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 181 | } |
| 182 | |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 183 | @Override |
| 184 | protected void onFinishInflate() { |
Gary Mai | 65971d0 | 2016-09-15 15:00:16 -0700 | [diff] [blame] | 185 | super.onFinishInflate(); |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 186 | setDrawingCacheEnabled(true); |
| 187 | setAlwaysDrawnWithCacheEnabled(true); |
| 188 | |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 189 | mLayoutInflater = (LayoutInflater) getContext().getSystemService( |
| 190 | Context.LAYOUT_INFLATER_SERVICE); |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 191 | |
| 192 | mEditors = (ViewGroup) findViewById(R.id.kind_editors); |
| 193 | mIcon = (ImageView) findViewById(R.id.kind_icon); |
| 194 | } |
| 195 | |
Walter Jang | 45b86d5 | 2015-10-15 15:23:16 -0700 | [diff] [blame] | 196 | public void setIsUserProfile(boolean isUserProfile) { |
| 197 | mIsUserProfile = isUserProfile; |
| 198 | } |
| 199 | |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 200 | /** |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 201 | * @param showOneEmptyEditor If true, we will always show one empty editor, otherwise an empty |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 202 | * editor will not be shown until the user enters a value. Note, this does not apply |
| 203 | * to name editors since those are always displayed. |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 204 | */ |
| 205 | public void setShowOneEmptyEditor(boolean showOneEmptyEditor) { |
| 206 | mShowOneEmptyEditor = showOneEmptyEditor; |
| 207 | } |
| 208 | |
| 209 | /** |
| 210 | * @param hideWhenEmpty If true, the entire section will be hidden if all inputs are empty, |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 211 | * otherwise one empty input will always be displayed. Note, this does not apply |
| 212 | * to name editors since those are always displayed. |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 213 | */ |
| 214 | public void setHideWhenEmpty(boolean hideWhenEmpty) { |
| 215 | mHideIfEmpty = hideWhenEmpty; |
| 216 | } |
| 217 | |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 218 | /** Binds the given group data to every {@link GroupMembershipView}. */ |
Walter Jang | f10ca15 | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 219 | public void setGroupMetaData(Cursor cursor) { |
| 220 | for (int i = 0; i < mEditors.getChildCount(); i++) { |
| 221 | final View view = mEditors.getChildAt(i); |
| 222 | if (view instanceof GroupMembershipView) { |
| 223 | ((GroupMembershipView) view).setGroupMetaData(cursor); |
| 224 | } |
| 225 | } |
| 226 | } |
| 227 | |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 228 | /** |
Walter Jang | 4f5594a | 2015-10-06 18:40:31 -0700 | [diff] [blame] | 229 | * Whether this is a name kind section view and all name fields (structured, phonetic, |
| 230 | * and nicknames) are empty. |
| 231 | */ |
| 232 | public boolean isEmptyName() { |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 233 | if (!StructuredName.CONTENT_ITEM_TYPE.equals(mKindSectionData.getMimeType())) { |
Walter Jang | 4f5594a | 2015-10-06 18:40:31 -0700 | [diff] [blame] | 234 | return false; |
| 235 | } |
| 236 | for (int i = 0; i < mEditors.getChildCount(); i++) { |
| 237 | final View view = mEditors.getChildAt(i); |
| 238 | if (view instanceof Editor) { |
| 239 | final Editor editor = (Editor) view; |
| 240 | if (!editor.isEmpty()) { |
| 241 | return false; |
| 242 | } |
| 243 | } |
| 244 | } |
| 245 | return true; |
| 246 | } |
| 247 | |
Gary Mai | 698cee7 | 2016-09-19 16:09:54 -0700 | [diff] [blame] | 248 | public StructuredNameEditorView getNameEditorView() { |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 249 | if (!StructuredName.CONTENT_ITEM_TYPE.equals(mKindSectionData.getMimeType()) |
Walter Jang | 4f5594a | 2015-10-06 18:40:31 -0700 | [diff] [blame] | 250 | || mEditors.getChildCount() == 0) { |
| 251 | return null; |
| 252 | } |
| 253 | return (StructuredNameEditorView) mEditors.getChildAt(0); |
| 254 | } |
| 255 | |
| 256 | /** |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 257 | * Binds views for the given {@link KindSectionData}. |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 258 | * |
| 259 | * We create a structured name and phonetic name editor for each {@link DataKind} with a |
Walter Jang | 4f5594a | 2015-10-06 18:40:31 -0700 | [diff] [blame] | 260 | * {@link StructuredName#CONTENT_ITEM_TYPE} mime type. The number and order of editors are |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 261 | * rendered as they are given to {@link #setState}. |
| 262 | * |
| 263 | * Empty name editors are never added and at least one structured name editor is always |
| 264 | * displayed, even if it is empty. |
| 265 | */ |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 266 | public void setState(KindSectionData kindSectionData, |
Gary Mai | 363af60 | 2016-09-28 10:01:23 -0700 | [diff] [blame] | 267 | ViewIdGenerator viewIdGenerator, RawContactEditorView.Listener listener) { |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 268 | mKindSectionData = kindSectionData; |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 269 | mViewIdGenerator = viewIdGenerator; |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 270 | mListener = listener; |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 271 | |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 272 | // Set the icon using the DataKind |
| 273 | final DataKind dataKind = mKindSectionData.getDataKind(); |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 274 | if (dataKind != null) { |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 275 | mIcon.setImageDrawable(EditorUiUtils.getMimeTypeDrawable(getContext(), |
| 276 | dataKind.mimeType)); |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 277 | if (mIcon.getDrawable() != null) { |
| 278 | mIcon.setContentDescription(dataKind.titleRes == -1 || dataKind.titleRes == 0 |
| 279 | ? "" : getResources().getString(dataKind.titleRes)); |
| 280 | } |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 281 | } |
| 282 | |
Gary Mai | 698cee7 | 2016-09-19 16:09:54 -0700 | [diff] [blame] | 283 | rebuildFromState(); |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 284 | |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 285 | updateEmptyEditors(/* shouldAnimate = */ false); |
| 286 | } |
| 287 | |
Gary Mai | 698cee7 | 2016-09-19 16:09:54 -0700 | [diff] [blame] | 288 | private void rebuildFromState() { |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 289 | mEditors.removeAllViews(); |
| 290 | |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 291 | final String mimeType = mKindSectionData.getMimeType(); |
| 292 | if (StructuredName.CONTENT_ITEM_TYPE.equals(mimeType)) { |
| 293 | addNameEditorViews(mKindSectionData.getAccountType(), |
Gary Mai | 698cee7 | 2016-09-19 16:09:54 -0700 | [diff] [blame] | 294 | mKindSectionData.getRawContactDelta()); |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 295 | } else if (GroupMembership.CONTENT_ITEM_TYPE.equals(mimeType)) { |
| 296 | addGroupEditorView(mKindSectionData.getRawContactDelta(), |
| 297 | mKindSectionData.getDataKind()); |
| 298 | } else { |
| 299 | final Editor.EditorListener editorListener; |
| 300 | if (Nickname.CONTENT_ITEM_TYPE.equals(mimeType)) { |
| 301 | editorListener = new OtherNameKindEditorListener(); |
| 302 | } else if (Event.CONTENT_ITEM_TYPE.equals(mimeType)) { |
| 303 | editorListener = new EventEditorListener(); |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 304 | } else { |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 305 | editorListener = new NonNameEditorListener(); |
| 306 | } |
| 307 | final List<ValuesDelta> valuesDeltas = mKindSectionData.getVisibleValuesDeltas(); |
| 308 | for (int i = 0; i < valuesDeltas.size(); i++ ) { |
| 309 | addNonNameEditorView(mKindSectionData.getRawContactDelta(), |
| 310 | mKindSectionData.getDataKind(), valuesDeltas.get(i), editorListener); |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 311 | } |
| 312 | } |
| 313 | } |
| 314 | |
Gary Mai | 698cee7 | 2016-09-19 16:09:54 -0700 | [diff] [blame] | 315 | private void addNameEditorViews(AccountType accountType, RawContactDelta rawContactDelta) { |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 316 | final boolean readOnly = !accountType.areContactsWritable(); |
Gary Mai | 698cee7 | 2016-09-19 16:09:54 -0700 | [diff] [blame] | 317 | final ValuesDelta nameValuesDelta = rawContactDelta |
| 318 | .getSuperPrimaryEntry(StructuredName.CONTENT_ITEM_TYPE); |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 319 | |
Walter Jang | 1ee24ed | 2015-09-25 17:49:14 -0700 | [diff] [blame] | 320 | if (readOnly) { |
Walter Jang | 82acd42 | 2015-10-17 14:01:27 -0700 | [diff] [blame] | 321 | final View nameView = mLayoutInflater.inflate( |
| 322 | R.layout.structured_name_readonly_editor_view, mEditors, |
| 323 | /* attachToRoot =*/ false); |
| 324 | |
| 325 | // Display name |
| 326 | ((TextView) nameView.findViewById(R.id.display_name)) |
Gary Mai | 698cee7 | 2016-09-19 16:09:54 -0700 | [diff] [blame] | 327 | .setText(nameValuesDelta.getDisplayName()); |
Walter Jang | 82acd42 | 2015-10-17 14:01:27 -0700 | [diff] [blame] | 328 | |
| 329 | // Account type info |
| 330 | final LinearLayout accountTypeLayout = (LinearLayout) |
| 331 | nameView.findViewById(R.id.account_type); |
| 332 | accountTypeLayout.setVisibility(View.VISIBLE); |
| 333 | ((ImageView) accountTypeLayout.findViewById(R.id.account_type_icon)) |
| 334 | .setImageDrawable(accountType.getDisplayIcon(getContext())); |
| 335 | ((TextView) accountTypeLayout.findViewById(R.id.account_type_name)) |
| 336 | .setText(accountType.getDisplayLabel(getContext())); |
| 337 | |
| 338 | mEditors.addView(nameView); |
Walter Jang | 1ee24ed | 2015-09-25 17:49:14 -0700 | [diff] [blame] | 339 | return; |
| 340 | } |
| 341 | |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 342 | // Structured name |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 343 | final StructuredNameEditorView nameView = (StructuredNameEditorView) mLayoutInflater |
| 344 | .inflate(R.layout.structured_name_editor_view, mEditors, /* attachToRoot =*/ false); |
Walter Jang | 45b86d5 | 2015-10-15 15:23:16 -0700 | [diff] [blame] | 345 | if (!mIsUserProfile) { |
| 346 | // Don't set super primary for the me contact |
| 347 | nameView.setEditorListener(new StructuredNameEditorListener( |
Gary Mai | 698cee7 | 2016-09-19 16:09:54 -0700 | [diff] [blame] | 348 | nameValuesDelta, rawContactDelta.getRawContactId(), mListener)); |
Walter Jang | 45b86d5 | 2015-10-15 15:23:16 -0700 | [diff] [blame] | 349 | } |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 350 | nameView.setDeletable(false); |
| 351 | nameView.setValues( |
Gary Mai | 7a6daea | 2016-10-10 15:41:48 -0700 | [diff] [blame] | 352 | accountType.getKindForMimetype(DataKind.PSEUDO_MIME_TYPE_NAME), |
Gary Mai | 698cee7 | 2016-09-19 16:09:54 -0700 | [diff] [blame] | 353 | nameValuesDelta, rawContactDelta, /* readOnly =*/ false, mViewIdGenerator); |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 354 | |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 355 | // Correct start margin since there is a second icon in the structured name layout |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 356 | nameView.findViewById(R.id.kind_icon).setVisibility(View.GONE); |
| 357 | mEditors.addView(nameView); |
| 358 | |
| 359 | // Phonetic name |
Marcus Hagerott | cf7f295 | 2016-09-06 13:49:17 -0700 | [diff] [blame] | 360 | final DataKind phoneticNameKind = accountType |
| 361 | .getKindForMimetype(DataKind.PSEUDO_MIME_TYPE_PHONETIC_NAME); |
| 362 | // The account type doesn't support phonetic name. |
| 363 | if (phoneticNameKind == null) return; |
| 364 | |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 365 | final PhoneticNameEditorView phoneticNameView = (PhoneticNameEditorView) mLayoutInflater |
| 366 | .inflate(R.layout.phonetic_name_editor_view, mEditors, /* attachToRoot =*/ false); |
| 367 | phoneticNameView.setEditorListener(new OtherNameKindEditorListener()); |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 368 | phoneticNameView.setDeletable(false); |
| 369 | phoneticNameView.setValues( |
| 370 | accountType.getKindForMimetype(DataKind.PSEUDO_MIME_TYPE_PHONETIC_NAME), |
Gary Mai | 698cee7 | 2016-09-19 16:09:54 -0700 | [diff] [blame] | 371 | nameValuesDelta, rawContactDelta, /* readOnly =*/ false, mViewIdGenerator); |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 372 | |
| 373 | // Fix the start margin for phonetic name views |
| 374 | final LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams( |
| 375 | LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT); |
| 376 | layoutParams.setMargins(0, 0, 0, 0); |
| 377 | phoneticNameView.setLayoutParams(layoutParams); |
| 378 | mEditors.addView(phoneticNameView); |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 379 | } |
| 380 | |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 381 | private void addGroupEditorView(RawContactDelta rawContactDelta, DataKind dataKind) { |
| 382 | final GroupMembershipView view = (GroupMembershipView) mLayoutInflater.inflate( |
Walter Jang | f10ca15 | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 383 | R.layout.item_group_membership, mEditors, /* attachToRoot =*/ false); |
| 384 | view.setKind(dataKind); |
| 385 | view.setEnabled(isEnabled()); |
| 386 | view.setState(rawContactDelta); |
| 387 | |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 388 | // Correct start margin since there is a second icon in the group layout |
Walter Jang | f10ca15 | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 389 | view.findViewById(R.id.kind_icon).setVisibility(View.GONE); |
| 390 | |
| 391 | mEditors.addView(view); |
| 392 | } |
| 393 | |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 394 | private View addNonNameEditorView(RawContactDelta rawContactDelta, DataKind dataKind, |
| 395 | ValuesDelta valuesDelta, Editor.EditorListener editorListener) { |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 396 | // Inflate the layout |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 397 | final View view = mLayoutInflater.inflate( |
| 398 | EditorUiUtils.getLayoutResourceId(dataKind.mimeType), mEditors, false); |
| 399 | view.setEnabled(isEnabled()); |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 400 | if (view instanceof Editor) { |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 401 | final Editor editor = (Editor) view; |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 402 | editor.setDeletable(true); |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 403 | editor.setEditorListener(editorListener); |
Walter Jang | 3e5ae0d | 2015-09-20 12:43:37 -0700 | [diff] [blame] | 404 | editor.setValues(dataKind, valuesDelta, rawContactDelta, !dataKind.editable, |
| 405 | mViewIdGenerator); |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 406 | } |
| 407 | mEditors.addView(view); |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 408 | |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 409 | return view; |
| 410 | } |
| 411 | |
| 412 | /** |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 413 | * Updates the editors being displayed to the user removing extra empty |
| 414 | * {@link Editor}s, so there is only max 1 empty {@link Editor} view at a time. |
| 415 | * If there is only 1 empty editor and {@link #setHideWhenEmpty} was set to true, |
| 416 | * then the entire section is hidden. |
| 417 | */ |
| 418 | public void updateEmptyEditors(boolean shouldAnimate) { |
Walter Jang | cbd431d | 2015-10-06 13:07:30 -0700 | [diff] [blame] | 419 | final boolean isNameKindSection = StructuredName.CONTENT_ITEM_TYPE.equals( |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 420 | mKindSectionData.getMimeType()); |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 421 | final boolean isGroupKindSection = GroupMembership.CONTENT_ITEM_TYPE.equals( |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 422 | mKindSectionData.getMimeType()); |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 423 | |
| 424 | if (isNameKindSection) { |
| 425 | // The name kind section is always visible |
| 426 | setVisibility(VISIBLE); |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 427 | updateEmptyNameEditors(shouldAnimate); |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 428 | } else if (isGroupKindSection) { |
| 429 | // Check whether metadata has been bound for all group views |
| 430 | for (int i = 0; i < mEditors.getChildCount(); i++) { |
| 431 | final View view = mEditors.getChildAt(i); |
Tingting Wang | 6dc36b0 | 2015-11-15 21:36:22 -0800 | [diff] [blame] | 432 | if (view instanceof GroupMembershipView) { |
| 433 | final GroupMembershipView groupView = (GroupMembershipView) view; |
| 434 | if (!groupView.wasGroupMetaDataBound() || !groupView.accountHasGroups()) { |
| 435 | setVisibility(GONE); |
| 436 | return; |
| 437 | } |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 438 | } |
| 439 | } |
| 440 | // Check that the user has selected to display all fields |
| 441 | if (mHideIfEmpty) { |
| 442 | setVisibility(GONE); |
| 443 | return; |
| 444 | } |
| 445 | setVisibility(VISIBLE); |
| 446 | |
| 447 | // We don't check the emptiness of the group views |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 448 | } else { |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 449 | // Determine if the entire kind section should be visible |
| 450 | final int editorCount = mEditors.getChildCount(); |
| 451 | final List<View> emptyEditors = getEmptyEditors(); |
| 452 | if (editorCount == emptyEditors.size() && mHideIfEmpty) { |
| 453 | setVisibility(GONE); |
| 454 | return; |
| 455 | } |
| 456 | setVisibility(VISIBLE); |
| 457 | |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 458 | updateEmptyNonNameEditors(shouldAnimate); |
| 459 | } |
| 460 | } |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 461 | |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 462 | private void updateEmptyNameEditors(boolean shouldAnimate) { |
| 463 | boolean isEmptyNameEditorVisible = false; |
| 464 | |
| 465 | for (int i = 0; i < mEditors.getChildCount(); i++) { |
| 466 | final View view = mEditors.getChildAt(i); |
Walter Jang | 4f5594a | 2015-10-06 18:40:31 -0700 | [diff] [blame] | 467 | if (view instanceof Editor) { |
| 468 | final Editor editor = (Editor) view; |
| 469 | if (view instanceof StructuredNameEditorView) { |
| 470 | // We always show one empty structured name view |
| 471 | if (editor.isEmpty()) { |
| 472 | if (isEmptyNameEditorVisible) { |
| 473 | // If we're already showing an empty editor then hide any other empties |
| 474 | if (mHideIfEmpty) { |
| 475 | view.setVisibility(View.GONE); |
| 476 | } |
| 477 | } else { |
| 478 | isEmptyNameEditorVisible = true; |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 479 | } |
| 480 | } else { |
Walter Jang | 4f5594a | 2015-10-06 18:40:31 -0700 | [diff] [blame] | 481 | showView(view, shouldAnimate); |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 482 | isEmptyNameEditorVisible = true; |
| 483 | } |
| 484 | } else { |
Walter Jang | 4f5594a | 2015-10-06 18:40:31 -0700 | [diff] [blame] | 485 | // Since we can't add phonetic names and nicknames, just show or hide them |
| 486 | if (mHideIfEmpty && editor.isEmpty()) { |
| 487 | hideView(view); |
| 488 | } else { |
| 489 | showView(view, /* shouldAnimate =*/ false); // Animation here causes jank |
| 490 | } |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 491 | } |
| 492 | } else { |
Walter Jang | 4f5594a | 2015-10-06 18:40:31 -0700 | [diff] [blame] | 493 | // For read only names, only show them if we're not hiding empty views |
| 494 | if (mHideIfEmpty) { |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 495 | hideView(view); |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 496 | } else { |
Walter Jang | 4f5594a | 2015-10-06 18:40:31 -0700 | [diff] [blame] | 497 | showView(view, shouldAnimate); |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 498 | } |
| 499 | } |
| 500 | } |
| 501 | } |
| 502 | |
| 503 | private void updateEmptyNonNameEditors(boolean shouldAnimate) { |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 504 | // Prune excess empty editors |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 505 | final List<View> emptyEditors = getEmptyEditors(); |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 506 | if (emptyEditors.size() > 1) { |
| 507 | // If there is more than 1 empty editor, then remove it from the list of editors. |
| 508 | int deleted = 0; |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 509 | for (int i = 0; i < emptyEditors.size(); i++) { |
| 510 | final View view = emptyEditors.get(i); |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 511 | // If no child {@link View}s are being focused on within this {@link View}, then |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 512 | // remove this empty editor. We can assume that at least one empty editor has |
| 513 | // focus. One way to get two empty editors is by deleting characters from a |
| 514 | // non-empty editor, in which case this editor has focus. Another way is if |
| 515 | // there is more values delta so we must also count number of editors deleted. |
| 516 | if (view.findFocus() == null) { |
| 517 | deleteView(view, shouldAnimate); |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 518 | deleted++; |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 519 | if (deleted == emptyEditors.size() - 1) break; |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 520 | } |
| 521 | } |
| 522 | return; |
| 523 | } |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 524 | // Determine if we should add a new empty editor |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 525 | final DataKind dataKind = mKindSectionData.getDataKind(); |
| 526 | final RawContactDelta rawContactDelta = mKindSectionData.getRawContactDelta(); |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 527 | if (dataKind == null // There is nothing we can do. |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 528 | // We have already reached the maximum number of editors, don't add any more. |
Tingting Wang | 6d8c629 | 2015-12-11 12:31:29 -0800 | [diff] [blame] | 529 | || !RawContactModifier.canInsert(rawContactDelta, dataKind) |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 530 | // We have already reached the maximum number of empty editors, don't add any more. |
| 531 | || emptyEditors.size() == 1) { |
| 532 | return; |
| 533 | } |
| 534 | // Add a new empty editor |
| 535 | if (mShowOneEmptyEditor) { |
Gary Mai | 98868d3 | 2016-09-14 11:55:04 -0700 | [diff] [blame] | 536 | final String mimeType = mKindSectionData.getMimeType(); |
Tingting Wang | f695eb3 | 2015-10-15 18:45:15 -0700 | [diff] [blame] | 537 | if (Nickname.CONTENT_ITEM_TYPE.equals(mimeType) && mEditors.getChildCount() > 0) { |
| 538 | return; |
| 539 | } |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 540 | final ValuesDelta values = RawContactModifier.insertChild(rawContactDelta, dataKind); |
Walter Jang | 4f5594a | 2015-10-06 18:40:31 -0700 | [diff] [blame] | 541 | final Editor.EditorListener editorListener = Event.CONTENT_ITEM_TYPE.equals(mimeType) |
| 542 | ? new EventEditorListener() : new NonNameEditorListener(); |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 543 | final View view = addNonNameEditorView(rawContactDelta, dataKind, values, |
Wenyi Wang | 2da5d2f | 2015-09-29 22:15:38 -0700 | [diff] [blame] | 544 | editorListener); |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 545 | showView(view, shouldAnimate); |
| 546 | } |
| 547 | } |
| 548 | |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 549 | private void hideView(View view) { |
| 550 | view.setVisibility(View.GONE); |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 551 | } |
| 552 | |
| 553 | private void deleteView(View view, boolean shouldAnimate) { |
| 554 | if (shouldAnimate) { |
| 555 | final Editor editor = (Editor) view; |
| 556 | editor.deleteEditor(); |
| 557 | } else { |
| 558 | mEditors.removeView(view); |
| 559 | } |
| 560 | } |
| 561 | |
| 562 | private void showView(View view, boolean shouldAnimate) { |
| 563 | if (shouldAnimate) { |
| 564 | view.setVisibility(View.GONE); |
Walter Jang | 192a01c | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 565 | EditorAnimator.getInstance().showFieldFooter(view); |
| 566 | } else { |
| 567 | view.setVisibility(View.VISIBLE); |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 568 | } |
| 569 | } |
| 570 | |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 571 | private List<View> getEmptyEditors() { |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 572 | final List<View> emptyEditors = new ArrayList<>(); |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 573 | for (int i = 0; i < mEditors.getChildCount(); i++) { |
Walter Jang | f10ca15 | 2015-09-22 15:23:55 -0700 | [diff] [blame] | 574 | final View view = mEditors.getChildAt(i); |
| 575 | if (view instanceof Editor && ((Editor) view).isEmpty()) { |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 576 | emptyEditors.add(view); |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 577 | } |
| 578 | } |
Walter Jang | 79658e1 | 2015-09-24 10:36:26 -0700 | [diff] [blame] | 579 | return emptyEditors; |
Walter Jang | f5dfea4 | 2015-09-16 12:30:36 -0700 | [diff] [blame] | 580 | } |
| 581 | } |