/android/import-contacts

To get this branch, use:
bzr branch http://bzr.ed.am/android/import-contacts

« back to all changes in this revision

Viewing changes to src/am/ed/importcontacts/VcardImporter.java

  • Committer: edam
  • Date: 2013-01-06 18:12:50 UTC
  • Revision ID: tim@ed.am-20130106181250-ymz5p33p1q7o06c4
bump version no. and update NEWS

Show diffs side-by-side

added added

removed removed

1
1
/*
2
2
 * VCFImporter.java
3
3
 *
4
 
 * Copyright (C) 2009 to 2013 Tim Marston <tim@ed.am>
 
4
 * Copyright (C) 2009 to 2011 Tim Marston <tim@ed.am>
5
5
 *
6
6
 * This file is part of the Import Contacts program (hereafter referred
7
 
 * to as "this program").  For more information, see
 
7
 * to as "this program"). For more information, see
8
8
 * http://ed.am/dev/android/import-contacts
9
9
 *
10
10
 * This program is free software: you can redistribute it and/or modify
45
45
import java.util.regex.Matcher;
46
46
import java.util.regex.Pattern;
47
47
 
 
48
import android.annotation.SuppressLint;
48
49
import android.content.SharedPreferences;
49
 
import android.os.Environment;
50
50
 
51
51
public class VcardImporter extends Importer
52
52
{
58
58
                super( doit );
59
59
        }
60
60
 
 
61
        @SuppressLint( "SdCardPath" )
61
62
        @Override
62
63
        protected void onImport() throws AbortImportException
63
64
        {
70
71
                File[] files = null;
71
72
                try
72
73
                {
73
 
                        // check SD card is mounted
74
 
                        String state = Environment.getExternalStorageState();
75
 
                        if( !Environment.MEDIA_MOUNTED.equals( state ) &&
76
 
                                !Environment.MEDIA_MOUNTED_READ_ONLY.equals( state ) )
77
 
                        {
78
 
                                showError( R.string.error_nosdcard );
79
 
                        }
80
 
 
81
74
                        // open directory
82
 
                        File file = new File( Environment.getExternalStorageDirectory(),
83
 
                                prefs.getString( "location", "/" ) );
 
75
                        String path = "/sdcard" + prefs.getString( "location", "/" );
 
76
                        File file = new File( path );
84
77
                        if( !file.exists() )
85
78
                                showError( R.string.error_locationnotfound );
86
79
 
90
83
                                // get files
91
84
                                class VCardFilter implements FilenameFilter {
92
85
                                        public boolean accept( File dir, String name ) {
93
 
                                                return name.toLowerCase( Locale.ENGLISH )
94
 
                                                        .endsWith( ".vcf" );
 
86
                                                return name.toLowerCase( Locale.US ).endsWith( ".vcf" );
95
87
                                        }
96
88
                                }
97
89
                                files = file.listFiles( new VCardFilter() );
141
133
                        boolean in_vcard = false;
142
134
                        while( ( line = reader.readLine() ) != null )
143
135
                        {
144
 
                                if( !in_vcard )
145
 
                                {
 
136
                                if( !in_vcard ) {
146
137
                                        // look for vcard beginning
147
 
                                        if( line.matches( "(?i)BEGIN[ \t]*:[ \t]*VCARD.*" ) ) {
 
138
                                        if( line.matches( "^BEGIN[ \t]*:[ \t]*VCARD.*$" ) ) {
148
139
                                                in_vcard = true;
149
140
                                                _vcard_count++;
150
141
                                        }
151
 
                                        // check for vMsg files
152
 
                                        else if( line.matches( "(?i)BEGIN[ \t]*:[ \t]*VMSG.*" ) ) {
153
 
                                                showError( getText( R.string.error_vcf_vmsgfile )
154
 
                                                        + file.getName() );
155
 
                                        }
156
142
                                }
157
 
                                else if( line.matches( "(?i)END[ \t]*:[ \t]*VCARD.*" ) )
 
143
                                else if( line.matches( "^END[ \t]*:[ \t]*VCARD.*$" ) )
158
144
                                        in_vcard = false;
159
145
                        }
160
 
                        reader.close();
161
146
 
162
147
                }
163
148
                catch( FileNotFoundException e ) {
185
170
                        FileInputStream istream = new FileInputStream( file );
186
171
                        byte[] content = new byte[ (int)file.length() ];
187
172
                        istream.read( content );
188
 
                        istream.close();
 
173
                        istream = null;
189
174
 
190
175
                        // import
191
176
                        importVCardFileContent( content, file.getName() );
218
203
 
219
204
                        if( vcard == null ) {
220
205
                                // look for vcard beginning
221
 
                                if( line.matches( "(?i)BEGIN[ \t]*:[ \t]*VCARD.*" ) ) {
 
206
                                if( line.matches( "^BEGIN[ \t]*:[ \t]*VCARD.*$" ) ) {
222
207
                                        setProgress( _progress++ );
223
208
                                        vcard = new Vcard();
224
209
                                        vcard_start_line = cli.getLineNumber();
226
211
                        }
227
212
                        else {
228
213
                                // look for vcard content or ending
229
 
                                if( line.matches( "(?i)END[ \t]*:[ \t]*VCARD.*" ) )
 
214
                                if( line.matches( "^END[ \t]*:[ \t]*VCARD.*$" ) )
230
215
                                {
231
216
                                        // finalise the vcard/contact
232
217
                                        try {
236
221
                                                importContact( vcard );
237
222
                                        }
238
223
                                        catch( Vcard.ParseException e ) {
239
 
                                                showContinueOrAbort(
 
224
                                                if( !showContinue(
240
225
                                                        getText( R.string.error_vcf_parse ).toString()
241
226
                                                        + fileName +
242
227
                                                        getText( R.string.error_vcf_parse_line ).toString()
243
 
                                                        + cli.getLineNumber() + ":\n" + e.getMessage() );
244
 
                                                skipContact();
 
228
                                                        + cli.getLineNumber() + ":\n" + e.getMessage() ) )
 
229
                                                {
 
230
                                                        finish( ACTION_ABORT );
 
231
                                                }
 
232
                                                else
 
233
                                                        skipContact();
245
234
                                        }
246
235
                                        catch( ContactData.ContactNotIdentifiableException e ) {
247
 
                                                showContinueOrAbort(
 
236
                                                if( !showContinue(
248
237
                                                        getText( R.string.error_vcf_parse ).toString()
249
238
                                                        + fileName +
250
239
                                                        getText( R.string.error_vcf_parse_line ).toString()
251
240
                                                        + vcard_start_line + ":\n" + getText(
252
 
                                                                R.string.error_vcf_notenoughinfo ).toString() );
253
 
                                                skipContact();
 
241
                                                                R.string.error_vcf_notenoughinfo ).toString()
 
242
                                                ) )
 
243
                                                {
 
244
                                                        finish( ACTION_ABORT );
 
245
                                                }
 
246
                                                else
 
247
                                                        skipContact();
254
248
                                        }
255
249
 
256
250
                                        // discard this vcard
264
258
                                        }
265
259
                                        catch( Vcard.ParseException e ) {
266
260
                                                skipContact();
267
 
                                                showContinueOrAbort(
 
261
                                                if( !showContinue(
268
262
                                                        getText( R.string.error_vcf_parse ).toString()
269
263
                                                        + fileName +
270
264
                                                        getText( R.string.error_vcf_parse_line ).toString()
271
 
                                                        + cli.getLineNumber() + "\n" + e.getMessage() );
 
265
                                                        + cli.getLineNumber() + "\n" + e.getMessage() ) )
 
266
                                                {
 
267
                                                        finish( ACTION_ABORT );
 
268
                                                }
272
269
 
273
 
                                                // Although we're continuing, we still need to abort
274
 
                                                // this vCard.  Further lines will be ignored until we
 
270
                                                // although we're continuing, we still need to abort
 
271
                                                // this vCard. Further lines will be ignored until we
275
272
                                                // get to another BEGIN:VCARD line.
276
273
                                                vcard = null;
277
274
                                        }
278
275
                                        catch( Vcard.SkipImportException e ) {
279
276
                                                skipContact();
280
 
                                                // Abort this vCard.  Further lines will be ignored until
 
277
                                                // abort this vCard. Further lines will be ignored until
281
278
                                                // we get to another BEGIN:VCARD line.
282
279
                                                vcard = null;
283
280
                                        }
468
465
                private String extractCollonPartFromLine( ContentLine content_line,
469
466
                        boolean former )
470
467
                {
 
468
                        String ret = null;
 
469
 
471
470
                        // split line into name and value parts and check to make sure we
472
471
                        // only got 2 parts and that the first part is not zero in length
473
472
                        String[] parts = content_line.getUsAsciiLine().split( ":", 2 );
474
473
                        if( parts.length == 2 && parts[ 0 ].length() > 0 )
475
 
                                return parts[ former? 0 : 1 ].trim();
 
474
                                ret = parts[ former? 0 : 1 ];
476
475
 
477
 
                        return null;
 
476
                        return ret;
478
477
                }
479
478
 
480
479
                private String extractNameAndParamsFromLine( ContentLine content_line )
481
480
                {
482
 
                        return extractCollonPartFromLine( content_line, true );
 
481
                        return extractCollonPartFromLine( content_line, true ).trim();
483
482
                }
484
483
 
485
484
                private String extractValueFromLine( ContentLine content_line )
503
502
                                        name_and_params.equalsIgnoreCase( "VERSION" ) )
504
503
                                {
505
504
                                        // yes, get it!
506
 
                                        String value = extractValueFromLine( content_line );
507
 
                                        if( value == null || (
508
 
                                                !value.equals( "2.1" ) && !value.equals( "3.0" ) ) )
509
 
                                        {
 
505
                                        String value = extractValueFromLine( content_line ).trim();
 
506
                                        if( !value.equals( "2.1" ) && !value.equals( "3.0" ) )
510
507
                                                throw new ParseException( R.string.error_vcf_version );
511
 
                                        }
512
508
                                        _version = value;
513
509
 
514
510
                                        // parse any buffers we've been accumulating while we waited
605
601
                                ) );
606
602
                                boolean is_interesting_field =
607
603
                                        interesting_fields.contains(
608
 
                                                name_param_parts[ 0 ].toUpperCase( Locale.ENGLISH ) );
 
604
                                                name_param_parts[ 0 ].toUpperCase( Locale.US ) );
609
605
 
610
606
                                // parse encoding parameter
611
607
                                String encoding = checkParam( name_param_parts, "ENCODING" );
612
608
                                if( encoding != null )
613
 
                                        encoding = encoding.toUpperCase( Locale.ENGLISH );
 
609
                                        encoding = encoding.toUpperCase( Locale.US );
614
610
                                if( is_interesting_field && encoding != null &&
615
611
                                        !encoding.equalsIgnoreCase( "8BIT" ) &&
616
612
                                        !encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )
622
618
                                // parse charset parameter
623
619
                                String charset = checkParam( name_param_parts, "CHARSET" );
624
620
                                if( charset != null )
625
 
                                        charset = charset.toUpperCase( Locale.ENGLISH );
 
621
                                        charset = charset.toUpperCase( Locale.US );
626
622
                                if( charset != null &&
627
623
                                        !charset.equalsIgnoreCase( "US-ASCII" ) &&
628
624
                                        !charset.equalsIgnoreCase( "ASCII" ) &&
721
717
                                        parseLABEL( name_param_parts, complete_value );
722
718
                                else if( name_param_parts[ 0 ].equalsIgnoreCase( "NOTE" ) )
723
719
                                        parseNOTE( name_param_parts, complete_value );
724
 
                                else if( name_param_parts[ 0 ].equalsIgnoreCase( "BDAY" ) )
725
 
                                        parseBDAY( name_param_parts, complete_value );
726
720
                        }
727
721
                }
728
722
 
752
746
                        {
753
747
                                String str = parts.get( a );
754
748
 
755
 
                                // Look for parts that end in an escape character, but ignore
756
 
                                // the final part.  We've already detected escape chars at the
 
749
                                // look for parts that end in an escape character, but ignore
 
750
                                // the final part. We've already detected escape chars at the
757
751
                                // end of the final part in parseLine() and handled multi-lines
758
752
                                // accordingly.
759
753
                                if( a < parts.size() - 1 &&
1029
1023
                        addNote( unescapeValue( value ) );
1030
1024
                }
1031
1025
 
1032
 
                private void parseBDAY( String[] params, String value )
1033
 
                {
1034
 
                        setBirthday( value );
1035
 
                }
1036
 
 
1037
1026
                public void finaliseVcard()
1038
1027
                        throws ParseException, ContactNotIdentifiableException
1039
1028
                {
1047
1036
 
1048
1037
                /**
1049
1038
                 * Amongst the params, find the value of the first, only, of any with
1050
 
                 * the specified name.
1051
 
                 *
 
1039
                 * the specified name
1052
1040
                 * @param params
1053
1041
                 * @param name
1054
1042
                 * @return a value, or null
1060
1048
                }
1061
1049
 
1062
1050
                /**
1063
 
                 * Amongst the params, find the values of any with the specified name.
1064
 
                 *
 
1051
                 * Amongst the params, find the values of any with the specified name
1065
1052
                 * @param params
1066
1053
                 * @param name
1067
1054
                 * @return an array of values, or null
1083
1070
                }
1084
1071
 
1085
1072
                /**
1086
 
                 * Amongst the params, return any type values present.  For v2.1 vCards,
1087
 
                 * those types are just parameters.  For v3.0, they are prefixed with
1088
 
                 * "TYPE=".  There may also be multiple type parameters.
1089
 
                 *
 
1073
                 * Amongst the params, return any type values present. For v2.1 vCards,
 
1074
                 * those types are just parameters. For v3.0, they are prefixed with
 
1075
                 * "TYPE=". There may also be multiple type parameters.
1090
1076
                 * @param params an array of params to look for types in
1091
1077
                 * @param valid_types an list of upper-case type values to look for
1092
1078
                 * @return a set of present type values
1104
1090
                                // this is in the specs!)
1105
1091
                                String[] parts = type_params[ a ].split( "," );
1106
1092
                                for( int i = 0; i < parts.length; i++ ) {
1107
 
                                        String ucpart = parts[ i ].toUpperCase( Locale.ENGLISH );
 
1093
                                        String ucpart = parts[ i ].toUpperCase( Locale.US );
1108
1094
                                        if( valid_types.contains( ucpart ) )
1109
1095
                                                types.add( ucpart );
1110
1096
                                }
1113
1099
                        // get 2.1-style type param
1114
1100
                        if( _version.equals( "2.1" ) ) {
1115
1101
                                for( int i = 1; i < params.length; i++ ) {
1116
 
                                        String ucparam = params[ i ].toUpperCase( Locale.ENGLISH );
 
1102
                                        String ucparam = params[ i ].toUpperCase( Locale.US );
1117
1103
                                        if( valid_types.contains( ucparam ) )
1118
1104
                                                types.add( ucparam );
1119
1105
                                }
1144
1130
                                else if( ch == '=' && i == in.limit() - 1 )
1145
1131
                                {
1146
1132
                                        // we found a '=' at the end of a line signifying a multi-
1147
 
                                        // line string, so we don't add it
 
1133
                                        // line string, so we don't add it.
1148
1134
                                        another = true;
1149
1135
                                        continue;
1150
1136
                                }