Home | History | Annotate | Download | only in model
      1 /*
      2  * Copyright (C) 2009 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.model;
     18 
     19 import com.android.contacts.R;
     20 import com.android.contacts.model.AccountType.DefinitionException;
     21 import com.android.contacts.util.DateUtils;
     22 import com.google.android.collect.Lists;
     23 
     24 import android.content.ContentValues;
     25 import android.content.Context;
     26 import android.provider.ContactsContract.CommonDataKinds.Email;
     27 import android.provider.ContactsContract.CommonDataKinds.Event;
     28 import android.provider.ContactsContract.CommonDataKinds.Im;
     29 import android.provider.ContactsContract.CommonDataKinds.Nickname;
     30 import android.provider.ContactsContract.CommonDataKinds.Note;
     31 import android.provider.ContactsContract.CommonDataKinds.Organization;
     32 import android.provider.ContactsContract.CommonDataKinds.Phone;
     33 import android.provider.ContactsContract.CommonDataKinds.Photo;
     34 import android.provider.ContactsContract.CommonDataKinds.StructuredName;
     35 import android.provider.ContactsContract.CommonDataKinds.StructuredPostal;
     36 import android.provider.ContactsContract.CommonDataKinds.Website;
     37 import android.util.Log;
     38 
     39 import java.util.Locale;
     40 
     41 public class ExchangeAccountType extends BaseAccountType {
     42     private static final String TAG = "ExchangeAccountType";
     43 
     44     public static final String ACCOUNT_TYPE = "com.android.exchange";
     45 
     46     public ExchangeAccountType(Context context, String authenticatorPackageName) {
     47         this.accountType = ACCOUNT_TYPE;
     48         this.resourcePackageName = null;
     49         this.syncAdapterPackageName = authenticatorPackageName;
     50 
     51         try {
     52             addDataKindStructuredName(context);
     53             addDataKindDisplayName(context);
     54             addDataKindPhoneticName(context);
     55             addDataKindNickname(context);
     56             addDataKindPhone(context);
     57             addDataKindEmail(context);
     58             addDataKindStructuredPostal(context);
     59             addDataKindIm(context);
     60             addDataKindOrganization(context);
     61             addDataKindPhoto(context);
     62             addDataKindNote(context);
     63             addDataKindEvent(context);
     64             addDataKindWebsite(context);
     65             addDataKindGroupMembership(context);
     66 
     67             mIsInitialized = true;
     68         } catch (DefinitionException e) {
     69             Log.e(TAG, "Problem building account type", e);
     70         }
     71     }
     72 
     73     @Override
     74     protected DataKind addDataKindStructuredName(Context context) throws DefinitionException {
     75         DataKind kind = addKind(new DataKind(StructuredName.CONTENT_ITEM_TYPE,
     76                 R.string.nameLabelsGroup, -1, true, R.layout.structured_name_editor_view));
     77         kind.actionHeader = new SimpleInflater(R.string.nameLabelsGroup);
     78         kind.actionBody = new SimpleInflater(Nickname.NAME);
     79 
     80         kind.typeOverallMax = 1;
     81 
     82         kind.fieldList = Lists.newArrayList();
     83         kind.fieldList.add(new EditField(StructuredName.PREFIX, R.string.name_prefix,
     84                 FLAGS_PERSON_NAME).setOptional(true));
     85         kind.fieldList.add(new EditField(StructuredName.FAMILY_NAME,
     86                 R.string.name_family, FLAGS_PERSON_NAME));
     87         kind.fieldList.add(new EditField(StructuredName.MIDDLE_NAME,
     88                 R.string.name_middle, FLAGS_PERSON_NAME));
     89         kind.fieldList.add(new EditField(StructuredName.GIVEN_NAME,
     90                 R.string.name_given, FLAGS_PERSON_NAME));
     91         kind.fieldList.add(new EditField(StructuredName.SUFFIX,
     92                 R.string.name_suffix, FLAGS_PERSON_NAME));
     93 
     94         kind.fieldList.add(new EditField(StructuredName.PHONETIC_FAMILY_NAME,
     95                 R.string.name_phonetic_family, FLAGS_PHONETIC));
     96         kind.fieldList.add(new EditField(StructuredName.PHONETIC_GIVEN_NAME,
     97                 R.string.name_phonetic_given, FLAGS_PHONETIC));
     98 
     99         return kind;
    100     }
    101 
    102     @Override
    103     protected DataKind addDataKindDisplayName(Context context) throws DefinitionException {
    104         DataKind kind = addKind(new DataKind(DataKind.PSEUDO_MIME_TYPE_DISPLAY_NAME,
    105                 R.string.nameLabelsGroup, -1, true, R.layout.text_fields_editor_view));
    106 
    107         boolean displayOrderPrimary =
    108                 context.getResources().getBoolean(R.bool.config_editor_field_order_primary);
    109         kind.typeOverallMax = 1;
    110 
    111         kind.fieldList = Lists.newArrayList();
    112         kind.fieldList.add(new EditField(StructuredName.PREFIX, R.string.name_prefix,
    113                 FLAGS_PERSON_NAME).setOptional(true));
    114         if (!displayOrderPrimary) {
    115             kind.fieldList.add(new EditField(StructuredName.FAMILY_NAME,
    116                     R.string.name_family, FLAGS_PERSON_NAME));
    117             kind.fieldList.add(new EditField(StructuredName.MIDDLE_NAME,
    118                     R.string.name_middle, FLAGS_PERSON_NAME).setOptional(true));
    119             kind.fieldList.add(new EditField(StructuredName.GIVEN_NAME,
    120                     R.string.name_given, FLAGS_PERSON_NAME));
    121         } else {
    122             kind.fieldList.add(new EditField(StructuredName.GIVEN_NAME,
    123                     R.string.name_given, FLAGS_PERSON_NAME));
    124             kind.fieldList.add(new EditField(StructuredName.MIDDLE_NAME,
    125                     R.string.name_middle, FLAGS_PERSON_NAME).setOptional(true));
    126             kind.fieldList.add(new EditField(StructuredName.FAMILY_NAME,
    127                     R.string.name_family, FLAGS_PERSON_NAME));
    128         }
    129         kind.fieldList.add(new EditField(StructuredName.SUFFIX,
    130                 R.string.name_suffix, FLAGS_PERSON_NAME).setOptional(true));
    131 
    132         return kind;
    133     }
    134 
    135     @Override
    136     protected DataKind addDataKindPhoneticName(Context context) throws DefinitionException {
    137         DataKind kind = addKind(new DataKind(DataKind.PSEUDO_MIME_TYPE_PHONETIC_NAME,
    138                 R.string.name_phonetic, -1, true, R.layout.phonetic_name_editor_view));
    139         kind.actionHeader = new SimpleInflater(R.string.nameLabelsGroup);
    140         kind.actionBody = new SimpleInflater(Nickname.NAME);
    141 
    142         kind.typeOverallMax = 1;
    143 
    144         kind.fieldList = Lists.newArrayList();
    145         kind.fieldList.add(new EditField(StructuredName.PHONETIC_FAMILY_NAME,
    146                 R.string.name_phonetic_family, FLAGS_PHONETIC));
    147         kind.fieldList.add(new EditField(StructuredName.PHONETIC_GIVEN_NAME,
    148                 R.string.name_phonetic_given, FLAGS_PHONETIC));
    149 
    150         return kind;
    151     }
    152 
    153     @Override
    154     protected DataKind addDataKindNickname(Context context) throws DefinitionException {
    155         final DataKind kind = super.addDataKindNickname(context);
    156 
    157         kind.typeOverallMax = 1;
    158 
    159         kind.fieldList = Lists.newArrayList();
    160         kind.fieldList.add(new EditField(Nickname.NAME, R.string.nicknameLabelsGroup,
    161                 FLAGS_PERSON_NAME));
    162 
    163         return kind;
    164     }
    165 
    166     @Override
    167     protected DataKind addDataKindPhone(Context context) throws DefinitionException {
    168         final DataKind kind = super.addDataKindPhone(context);
    169 
    170         kind.typeColumn = Phone.TYPE;
    171         kind.typeList = Lists.newArrayList();
    172         kind.typeList.add(buildPhoneType(Phone.TYPE_MOBILE).setSpecificMax(1));
    173         kind.typeList.add(buildPhoneType(Phone.TYPE_HOME).setSpecificMax(2));
    174         kind.typeList.add(buildPhoneType(Phone.TYPE_WORK).setSpecificMax(2));
    175         kind.typeList.add(buildPhoneType(Phone.TYPE_FAX_WORK).setSecondary(true)
    176                 .setSpecificMax(1));
    177         kind.typeList.add(buildPhoneType(Phone.TYPE_FAX_HOME).setSecondary(true)
    178                 .setSpecificMax(1));
    179         kind.typeList
    180                 .add(buildPhoneType(Phone.TYPE_PAGER).setSecondary(true).setSpecificMax(1));
    181         kind.typeList.add(buildPhoneType(Phone.TYPE_CAR).setSecondary(true).setSpecificMax(1));
    182         kind.typeList.add(buildPhoneType(Phone.TYPE_COMPANY_MAIN).setSecondary(true)
    183                 .setSpecificMax(1));
    184         kind.typeList.add(buildPhoneType(Phone.TYPE_MMS).setSecondary(true).setSpecificMax(1));
    185         kind.typeList
    186                 .add(buildPhoneType(Phone.TYPE_RADIO).setSecondary(true).setSpecificMax(1));
    187         kind.typeList.add(buildPhoneType(Phone.TYPE_ASSISTANT).setSecondary(true)
    188                 .setSpecificMax(1));
    189 
    190         kind.fieldList = Lists.newArrayList();
    191         kind.fieldList.add(new EditField(Phone.NUMBER, R.string.phoneLabelsGroup, FLAGS_PHONE));
    192 
    193         return kind;
    194     }
    195 
    196     @Override
    197     protected DataKind addDataKindEmail(Context context) throws DefinitionException {
    198         final DataKind kind = super.addDataKindEmail(context);
    199 
    200         kind.typeOverallMax = 3;
    201 
    202         kind.fieldList = Lists.newArrayList();
    203         kind.fieldList.add(new EditField(Email.DATA, R.string.emailLabelsGroup, FLAGS_EMAIL));
    204 
    205         return kind;
    206     }
    207 
    208     @Override
    209     protected DataKind addDataKindStructuredPostal(Context context) throws DefinitionException {
    210         final DataKind kind = super.addDataKindStructuredPostal(context);
    211 
    212         final boolean useJapaneseOrder =
    213             Locale.JAPANESE.getLanguage().equals(Locale.getDefault().getLanguage());
    214         kind.typeColumn = StructuredPostal.TYPE;
    215         kind.typeList = Lists.newArrayList();
    216         kind.typeList.add(buildPostalType(StructuredPostal.TYPE_WORK).setSpecificMax(1));
    217         kind.typeList.add(buildPostalType(StructuredPostal.TYPE_HOME).setSpecificMax(1));
    218         kind.typeList.add(buildPostalType(StructuredPostal.TYPE_OTHER).setSpecificMax(1));
    219 
    220         kind.fieldList = Lists.newArrayList();
    221         if (useJapaneseOrder) {
    222             kind.fieldList.add(new EditField(StructuredPostal.COUNTRY,
    223                     R.string.postal_country, FLAGS_POSTAL).setOptional(true));
    224             kind.fieldList.add(new EditField(StructuredPostal.POSTCODE,
    225                     R.string.postal_postcode, FLAGS_POSTAL));
    226             kind.fieldList.add(new EditField(StructuredPostal.REGION,
    227                     R.string.postal_region, FLAGS_POSTAL));
    228             kind.fieldList.add(new EditField(StructuredPostal.CITY,
    229                     R.string.postal_city,FLAGS_POSTAL));
    230             kind.fieldList.add(new EditField(StructuredPostal.STREET,
    231                     R.string.postal_street, FLAGS_POSTAL));
    232         } else {
    233             kind.fieldList.add(new EditField(StructuredPostal.STREET,
    234                     R.string.postal_street, FLAGS_POSTAL));
    235             kind.fieldList.add(new EditField(StructuredPostal.CITY,
    236                     R.string.postal_city,FLAGS_POSTAL));
    237             kind.fieldList.add(new EditField(StructuredPostal.REGION,
    238                     R.string.postal_region, FLAGS_POSTAL));
    239             kind.fieldList.add(new EditField(StructuredPostal.POSTCODE,
    240                     R.string.postal_postcode, FLAGS_POSTAL));
    241             kind.fieldList.add(new EditField(StructuredPostal.COUNTRY,
    242                     R.string.postal_country, FLAGS_POSTAL).setOptional(true));
    243         }
    244 
    245         return kind;
    246     }
    247 
    248     @Override
    249     protected DataKind addDataKindIm(Context context) throws DefinitionException {
    250         final DataKind kind = super.addDataKindIm(context);
    251 
    252         // Types are not supported for IM. There can be 3 IMs, but OWA only shows only the first
    253         kind.typeOverallMax = 3;
    254 
    255         kind.defaultValues = new ContentValues();
    256         kind.defaultValues.put(Im.TYPE, Im.TYPE_OTHER);
    257 
    258         kind.fieldList = Lists.newArrayList();
    259         kind.fieldList.add(new EditField(Im.DATA, R.string.imLabelsGroup, FLAGS_EMAIL));
    260 
    261         return kind;
    262     }
    263 
    264     @Override
    265     protected DataKind addDataKindOrganization(Context context) throws DefinitionException {
    266         final DataKind kind = super.addDataKindOrganization(context);
    267 
    268         kind.typeOverallMax = 1;
    269 
    270         kind.fieldList = Lists.newArrayList();
    271         kind.fieldList.add(new EditField(Organization.COMPANY, R.string.ghostData_company,
    272                 FLAGS_GENERIC_NAME));
    273         kind.fieldList.add(new EditField(Organization.TITLE, R.string.ghostData_title,
    274                 FLAGS_GENERIC_NAME));
    275 
    276         return kind;
    277     }
    278 
    279     @Override
    280     protected DataKind addDataKindPhoto(Context context) throws DefinitionException {
    281         final DataKind kind = super.addDataKindPhoto(context);
    282 
    283         kind.typeOverallMax = 1;
    284 
    285         kind.fieldList = Lists.newArrayList();
    286         kind.fieldList.add(new EditField(Photo.PHOTO, -1, -1));
    287 
    288         return kind;
    289     }
    290 
    291     @Override
    292     protected DataKind addDataKindNote(Context context) throws DefinitionException {
    293         final DataKind kind = super.addDataKindNote(context);
    294 
    295         kind.fieldList = Lists.newArrayList();
    296         kind.fieldList.add(new EditField(Note.NOTE, R.string.label_notes, FLAGS_NOTE));
    297 
    298         return kind;
    299     }
    300 
    301     protected DataKind addDataKindEvent(Context context) throws DefinitionException {
    302         DataKind kind = addKind(
    303                 new DataKind(Event.CONTENT_ITEM_TYPE, R.string.eventLabelsGroup, 150, true,
    304                 R.layout.event_field_editor_view));
    305         kind.actionHeader = new EventActionInflater();
    306         kind.actionBody = new SimpleInflater(Event.START_DATE);
    307 
    308         kind.typeOverallMax = 1;
    309 
    310         kind.typeColumn = Event.TYPE;
    311         kind.typeList = Lists.newArrayList();
    312         kind.typeList.add(buildEventType(Event.TYPE_BIRTHDAY, false).setSpecificMax(1));
    313 
    314         kind.dateFormatWithYear = DateUtils.DATE_AND_TIME_FORMAT;
    315 
    316         kind.fieldList = Lists.newArrayList();
    317         kind.fieldList.add(new EditField(Event.DATA, R.string.eventLabelsGroup, FLAGS_EVENT));
    318 
    319         return kind;
    320     }
    321 
    322     @Override
    323     protected DataKind addDataKindWebsite(Context context) throws DefinitionException {
    324         final DataKind kind = super.addDataKindWebsite(context);
    325 
    326         kind.typeOverallMax = 1;
    327 
    328         kind.fieldList = Lists.newArrayList();
    329         kind.fieldList.add(new EditField(Website.URL, R.string.websiteLabelsGroup, FLAGS_WEBSITE));
    330 
    331         return kind;
    332     }
    333 
    334     @Override
    335     public boolean isGroupMembershipEditable() {
    336         return true;
    337     }
    338 
    339     @Override
    340     public boolean areContactsWritable() {
    341         return true;
    342     }
    343 }
    344