@chen834921478/react-native-select-contact 1.6.3

package/android/src/main/java/com/streem/selectcontact/SelectContactModule.java

@@ -0,0 +1,271 @@
+package com.streem.selectcontact;
+
+import android.app.Activity;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.database.Cursor;
+import android.net.Uri;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.CommonDataKinds.Email;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.CommonDataKinds.StructuredName;
+import android.provider.ContactsContract.CommonDataKinds.StructuredPostal;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.Contacts.Entity;
+import android.util.Log;
+
+import com.facebook.react.bridge.ActivityEventListener;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+
+public class SelectContactModule extends ReactContextBaseJavaModule implements ActivityEventListener {
+
+    private static final String TAG = "SelectContactModule";
+    private static final int CONTACT_REQUEST = 11112;
+    public static final String E_CONTACT_CANCELLED = "E_CONTACT_CANCELLED";
+    public static final String E_CONTACT_NO_DATA = "E_CONTACT_NO_DATA";
+    public static final String E_CONTACT_EXCEPTION = "E_CONTACT_EXCEPTION";
+    public static final String E_CONTACT_PERMISSION = "E_CONTACT_PERMISSION";
+    private Promise mContactsPromise;
+    private final ContentResolver contentResolver;
+
+    public SelectContactModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.contentResolver = getReactApplicationContext().getContentResolver();
+        reactContext.addActivityEventListener(this);
+    }
+
+    @Override
+    public String getName() {
+        return "SelectContact";
+    }
+
+
+    @ReactMethod
+    public void openContactSelection(Promise contactsPromise) {
+        launchPicker(contactsPromise, CONTACT_REQUEST);
+    }
+
+    /**
+     * Lanch the contact picker, with the specified requestCode for returned data.
+     *
+     * @param contactsPromise - promise passed in from React Native.
+     * @param requestCode     - request code to specify what contact data to return
+     */
+    private void launchPicker(Promise contactsPromise, int requestCode) {
+        mContactsPromise = contactsPromise;
+       
+            Intent intent = new Intent(Intent.ACTION_PICK,ContactsContract.CommonDataKinds.Phone.CONTENT_URI);
+//            intent.setType(Contacts.CONTENT_TYPE);
+            Activity activity = getCurrentActivity();
+            if (intent.resolveActivity(activity.getPackageManager()) != null) {
+                activity.startActivityForResult(intent, requestCode);
+            }
+       
+    }
+
+    @Override
+    public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent intent) {
+        if (mContactsPromise == null || requestCode != CONTACT_REQUEST) {
+            return;
+        }
+
+        //Request was cancelled
+        if (resultCode != Activity.RESULT_OK) {
+            mContactsPromise.reject(E_CONTACT_CANCELLED, "Cancelled");
+            return;
+        }
+
+        // Retrieve all possible data about contact and return as a JS object
+        WritableMap contactData = Arguments.createMap();
+
+        try {
+//            String id = getContactId(intent.getData());
+//            contactData.putString("recordId", id);
+//            Uri contactUri = buildContactUri(id);
+            boolean foundData = false;
+
+            WritableArray phones = Arguments.createArray();
+            WritableArray emails = Arguments.createArray();
+            WritableArray postalAddresses = Arguments.createArray();
+
+
+
+            Cursor cursor = activity.getContentResolver().query(intent.getData(), null, null, null, null);
+            if (cursor != null &&  cursor.moveToFirst()) {
+
+         int any=cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER);
+                String number = cursor.getString(any);
+                String fullName = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME));
+                foundData= true;
+                addPhoneEntry(phones, cursor, activity);
+                contactData.putArray("phones", phones);
+                contactData.putString("phone", number);
+                contactData.putString("name", fullName);
+    
+            }
+            cursor.close();
+
+
+//            contactData.putArray("postalAddresses", postalAddresses);
+
+            if (foundData) {
+                mContactsPromise.resolve(contactData);
+            } else {
+                mContactsPromise.reject(E_CONTACT_NO_DATA, "No data found for contact");
+            }
+//        } catch (SelectContactException e) {
+//            mContactsPromise.reject(E_CONTACT_EXCEPTION, e.getMessage());
+        } catch (Exception e) {
+            Log.e(TAG, "Unexpected exception reading from contacts", e);
+            mContactsPromise.reject(E_CONTACT_EXCEPTION, e.getMessage());
+        }
+    }
+
+    private String getContactId(Uri contactUri) throws SelectContactException {
+        Cursor cursor = this.contentResolver.query(contactUri, null, null, null, null);
+        if (cursor == null || !cursor.moveToFirst()) {
+            throw new SelectContactException(E_CONTACT_NO_DATA, "Contact Data Not Found");
+        }
+
+        return cursor.getString(cursor.getColumnIndex(Contacts._ID));
+    }
+
+    private Uri buildContactUri(String id) {
+        return Uri
+                .withAppendedPath(Contacts.CONTENT_URI, id)
+                .buildUpon()
+                .appendPath(Entity.CONTENT_DIRECTORY)
+                .build();
+    }
+
+    private Cursor openContactQuery(Uri contactUri) throws SelectContactException {
+        String[] projection = {
+                Entity.MIMETYPE,
+                Entity.DATA1,
+                Entity.DATA2,
+                Entity.DATA3
+        };
+        String sortOrder = Entity.RAW_CONTACT_ID + " ASC";
+        Cursor cursor = this.contentResolver.query(contactUri, projection, null, null, sortOrder);
+        if (cursor == null) {
+            throw new SelectContactException(E_CONTACT_EXCEPTION, "Could not query contacts data. Unable to create cursor.");
+        }
+
+        return cursor;
+    }
+
+    private void addNameData(WritableMap contactData, Cursor cursor) {
+        int displayNameIndex = cursor.getColumnIndex(StructuredName.DISPLAY_NAME);
+        contactData.putString("name", cursor.getString(displayNameIndex));
+
+        int givenNameColumn = cursor.getColumnIndex(StructuredName.GIVEN_NAME);
+        if (givenNameColumn != -1) {
+            String givenName = cursor.getString(givenNameColumn);
+            contactData.putString("givenName", givenName);
+        }
+
+        int familyNameColumn = cursor.getColumnIndex(StructuredName.FAMILY_NAME);
+        if (familyNameColumn != -1) {
+            String familyName = cursor.getString(cursor.getColumnIndex(StructuredName.FAMILY_NAME));
+            contactData.putString("familyName", familyName);
+        }
+
+        int middleNameColumn = cursor.getColumnIndex(StructuredName.MIDDLE_NAME);
+        if (middleNameColumn != -1) {
+            String middleName = cursor.getString(middleNameColumn);
+            contactData.putString("middleName", middleName);
+        }
+    }
+
+    private void addPostalData(WritableArray postalAddresses, Cursor cursor, Activity activity) {
+        // we need to see if the postal address columns exist, if so, add them
+        int formattedAddressColumn = cursor.getColumnIndex(StructuredPostal.FORMATTED_ADDRESS);
+        int streetColumn = cursor.getColumnIndex(StructuredPostal.STREET);
+        int cityColumn = cursor.getColumnIndex(StructuredPostal.CITY);
+        int stateColumn = cursor.getColumnIndex(StructuredPostal.REGION);
+        int postalCodeColumn = cursor.getColumnIndex(StructuredPostal.POSTCODE);
+        int isoCountryCodeColumn = cursor.getColumnIndex(StructuredPostal.COUNTRY);
+
+        WritableMap addressEntry = Arguments.createMap();
+        if (formattedAddressColumn != -1) {
+            addressEntry.putString("formattedAddress", cursor.getString(formattedAddressColumn));
+        }
+        if (streetColumn != -1) {
+            addressEntry.putString("street", cursor.getString(streetColumn));
+        }
+        if (cityColumn != -1) {
+            addressEntry.putString("city", cursor.getString(cityColumn));
+        }
+        if (stateColumn != -1) {
+            addressEntry.putString("state", cursor.getString(stateColumn));
+        }
+        if (postalCodeColumn != -1) {
+            addressEntry.putString("postalCode", cursor.getString(postalCodeColumn));
+        }
+        if (isoCountryCodeColumn != -1) {
+            addressEntry.putString("isoCountryCode", cursor.getString(isoCountryCodeColumn));
+        }
+
+        // add the address type here
+        int addressTypeColumn = cursor.getColumnIndex(StructuredPostal.TYPE);
+        int addressLabelColumn = cursor.getColumnIndex(StructuredPostal.LABEL);
+        if (addressTypeColumn != -1 && addressLabelColumn != -1) {
+            String addressLabel = cursor.getString(addressLabelColumn);
+            int addressType = cursor.getInt(addressTypeColumn);
+            CharSequence typeLabel = StructuredPostal.getTypeLabel(activity.getResources(), addressType, addressLabel);
+            addressEntry.putString("type", String.valueOf(typeLabel));
+        }
+
+        postalAddresses.pushMap(addressEntry);
+    }
+
+    private void addPhoneEntry(WritableArray phones, Cursor cursor, Activity activity) {
+        String phoneNumber = cursor.getString(cursor.getColumnIndex(Phone.NUMBER));
+        int phoneType = cursor.getInt(cursor.getColumnIndex(Phone.TYPE));
+        String phoneLabel = cursor.getString(cursor.getColumnIndex(Phone.LABEL));
+        CharSequence typeLabel = Phone.getTypeLabel(activity.getResources(), phoneType, phoneLabel);
+
+        WritableMap phoneEntry = Arguments.createMap();
+        phoneEntry.putString("number", phoneNumber);
+        phoneEntry.putString("type", String.valueOf(typeLabel));
+
+        phones.pushMap(phoneEntry);
+    }
+
+    private void addEmailEntry(WritableArray emails, Cursor cursor, Activity activity) {
+        String emailAddress = cursor.getString(cursor.getColumnIndex(Email.ADDRESS));
+        int emailType = cursor.getInt(cursor.getColumnIndex(Email.TYPE));
+        String emailLabel = cursor.getString(cursor.getColumnIndex(Email.LABEL));
+        CharSequence typeLabel = Email.getTypeLabel(activity.getResources(), emailType, emailLabel);
+
+        WritableMap emailEntry = Arguments.createMap();
+        emailEntry.putString("address", emailAddress);
+        emailEntry.putString("type", String.valueOf(typeLabel));
+
+        emails.pushMap(emailEntry);
+    }
+
+    @Override
+    public void onNewIntent(Intent intent) {
+
+    }
+
+    public static class SelectContactException extends Exception {
+        private final String errorCode;
+
+        public SelectContactException(String errorCode, String errorMessage) {
+            super(errorMessage);
+            this.errorCode = errorCode;
+        }
+
+        public String getErrorCode() {
+            return errorCode;
+        }
+    }
+}

package/android/src/main/java/com/streem/selectcontact/SelectContactPackage.java

@@ -0,0 +1,25 @@
+package com.streem.selectcontact;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class SelectContactPackage implements ReactPackage {
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new SelectContactModule(reactContext));
+        return modules;
+    }
+}

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">ContactsWrapper</string>
+</resources>

package/android/src/main/res/values/styles.xml

@@ -0,0 +1,8 @@
+<resources>
+
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
+        <!-- Customize your theme here. -->
+    </style>
+
+</resources>

package/index.js

@@ -0,0 +1,204 @@
+'use strict';
+
+import {
+    Alert,
+    ActionSheetIOS,
+    NativeModules,
+    Platform
+} from 'react-native';
+
+const { SelectContact, ActionSheetAndroid } = NativeModules;
+const ActionSheet = Platform.select({
+    ios: ActionSheetIOS,
+    android: ActionSheetAndroid
+});
+
+const DEFAULT_TEXT_OPTIONS = {
+    cancel: "Cancel", 
+    selectPhone: "Select Phone", 
+    selectPostalAddress: "Select Postal Address",
+    selectEmail: "Select Email",
+    errorNoPhoneNumbersTitle: "No Phone Numbers", 
+    errorNoPhoneNumbersBody: "We could not find any phone numbers for ",
+    errorNoAddressTitle: "No Postal Addresses",
+    errorNoAddressBody: "We could not find any postal addresses for ",
+    errorNoEmailTitle: "No Email Addresses",
+    errorNoEmailBody: "We could not find any email addresses for ",
+    errorOpenTwice: "Cannot open the contact selector twice",
+}
+
+let currentlyOpen = false;
+
+const SelectContactApi = {
+
+    selectContact(textOptions=DEFAULT_TEXT_OPTIONS) {
+        if (currentlyOpen) {
+            return Promise.reject(new Error(textOptions.errorOpenTwice));
+        }
+
+        currentlyOpen = true;
+
+        return SelectContact.openContactSelection()
+            .then(contact => {
+                currentlyOpen = false;
+                return contact;
+            })
+            .catch(err => {
+                currentlyOpen = false;
+
+                // Resolve to null when cancelled
+                if (err.code === 'E_CONTACT_CANCELLED') {
+                    return null;
+                }
+
+                throw err;
+            });
+    },
+
+    selectContactPostalAddress(textOptions=DEFAULT_TEXT_OPTIONS) {
+      return SelectContactApi.selectContact(textOptions)
+          .then(contact => {
+              if (!contact) {
+                  return null;
+              }
+
+              let addresses = contact && contact.postalAddresses || [];
+              if (addresses.length === 0) {
+                  Alert.alert(textOptions.errorNoAddressTitle, `${textOptions.errorNoAddressBody}${contact.name}`);
+                  return null;
+              }
+
+              return selectPostalAddress(addresses)
+                  .then(selectedAddress => {
+                      return selectedAddress ? { contact, selectedAddress } : null;
+                  });
+          })
+    },
+
+    selectContactPhone(textOptions=DEFAULT_TEXT_OPTIONS) {
+        return SelectContactApi.selectContact(textOptions)
+            .then(contact => {
+                if (!contact) {
+                    return null;
+                }
+
+                let phones = contact && contact.phones || [];
+                if (phones.length === 0) {
+                    Alert.alert(textOptions.errorNoPhoneNumbersTitle, `${textOptions.errorNoPhoneNumbersBody}${contact.name}`);
+                    return null;
+                }
+
+                return selectPhone(phones, textOptions)
+                    .then(selectedPhone => {
+                        return selectedPhone ? { contact, selectedPhone } : null;
+                    });
+            });
+    },
+
+    selectContactEmail(textOptions=DEFAULT_TEXT_OPTIONS) {
+        return SelectContactApi.selectContact(textOptions)
+            .then(contact => {
+                if (!contact) {
+                    return null;
+                }
+
+                let emails = contact && contact.emails || [];
+                if (emails.length === 0) {
+                    Alert.alert(textOptions.errorNoEmailTitle, `${textOptions.errorNoEmailBody}${contact.name}`);
+                    return null;
+                }
+
+                return selectEmail(emails)
+                    .then(selectedEmail => {
+                        return selectedEmail ? { contact, selectedEmail } : null;
+                    });
+            });
+    }
+
+};
+
+module.exports = SelectContactApi;
+
+
+function selectPhone(phones, textOptions) {
+    if (phones.length < 2 || !ActionSheet) {
+        return Promise.resolve(phones[0]);
+    }
+
+    let options = phones.map(phone => {
+        let { number, type } = phone;
+        return number + (type ? ` - ${type}` : '');
+    });
+
+    if (Platform.OS === 'ios') {
+        options.push(textOptions.cancel);
+    }
+
+    return new Promise(((resolve) => {
+        ActionSheet.showActionSheetWithOptions({
+                title: textOptions.selectPhone,
+                options: options,
+                cancelButtonIndex: options.length - 1,
+            },
+            (buttonIndex) => {
+                resolve(phones[buttonIndex]);
+            });
+    }));
+}
+
+function selectPostalAddress(addresses, textOptions) {
+  if (addresses.length < 2 || !ActionSheet) {
+    return Promise.resolve(addresses[0]);
+  }
+
+  let options = addresses.map(address => {
+    let { formattedAddress, street, city, state, postalCode, isoCountryCode } = address;
+
+    if (formattedAddress) {
+      return formattedAddress;
+    }
+
+    return `${street} ${city}, ${state} ${postalCode} ${isoCountryCode}`;
+  });
+
+  if (Platform.OS === 'ios') {
+    options.push(textOptions.cancel);
+  }
+
+  return new Promise(((resolve) => {
+      ActionSheet.showActionSheetWithOptions({
+              title: textOptions.selectPostalAddress,
+              options: options,
+              cancelButtonIndex: options.length - 1,
+          },
+          (buttonIndex) => {
+              resolve(addresses[buttonIndex]);
+          });
+  }));
+}
+
+function selectEmail(emails) {
+    if (emails.length < 2 || !ActionSheet) {
+        return Promise.resolve(emails[0]);
+    }
+
+    let options = emails.map(email => {
+        let { address, type } = email;
+        return address + (type ? ` - ${type}` : '');
+    });
+
+    if (Platform.OS === 'ios') {
+        options.push(textOptions.cancel);
+    }
+
+    return new Promise(((resolve) => {
+        ActionSheet.showActionSheetWithOptions({
+                title: textOptions.selectEmail,
+                options: options,
+                cancelButtonIndex: options.length - 1,
+            },
+            (buttonIndex) => {
+                resolve(emails[buttonIndex]);
+            });
+    }));
+}

package/ios/RCTSelectContact/RCTSelectContact.h

@@ -0,0 +1,13 @@
+//
+//  RCTSelectContact.h
+//  RCTSelectContact
+//
+
+#import <React/RCTBridgeModule.h>
+
+@import Contacts;
+@import ContactsUI;
+
+@interface RCTSelectContact : NSObject <RCTBridgeModule, CNContactPickerDelegate>
+
+@end

package/ios/RCTSelectContact/RCTSelectContact.m

@@ -0,0 +1,107 @@
+//
+//  RCTSelectContact.m
+//  RCTSelectContact
+//
+
+@import Foundation;
+#import "RCTSelectContact.h"
+@interface RCTSelectContact()
+
+@property(nonatomic, retain) RCTPromiseResolveBlock _resolve;
+@property(nonatomic, retain) RCTPromiseRejectBlock _reject;
+
+@end
+
+
+@implementation RCTSelectContact
+
+RCT_EXPORT_MODULE(SelectContact);
+
+RCT_EXPORT_METHOD(openContactSelection:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+  self._resolve = resolve;
+  self._reject = reject;
+  
+  UIViewController *picker = [[CNContactPickerViewController alloc] init];
+  ((CNContactPickerViewController *)picker).delegate = self;
+  
+  // Launch Contact Picker
+  UIViewController *root = [[[UIApplication sharedApplication] delegate] window].rootViewController;
+  while(root.presentedViewController) {
+    root = root.presentedViewController;
+  }
+  [root presentViewController:picker animated:YES completion:nil];
+}
+
+- (NSMutableDictionary *) emptyContactDict {
+  NSMutableArray *phones = [[NSMutableArray alloc] init];
+  NSMutableArray *emails = [[NSMutableArray alloc] init];
+  NSMutableArray *addresses = [[NSMutableArray alloc] init];
+  return [[NSMutableDictionary alloc] initWithObjects:@[@"", @"", @"", @"", phones, emails, addresses]
+                                              forKeys:@[@"name", @"givenName", @"middleName", @"familyName", @"phones", @"emails", @"postalAddresses"]];
+}
+
+#pragma mark - CNContactPickerDelegate
+- (void)contactPicker:(CNContactPickerViewController *)picker didSelectContact:(CNContact *)contact {
+  
+  /* Return NSDictionary ans JS Object to RN, containing basic contact data
+   This is a starting point, in future more fields should be added, as required.
+   */
+  NSMutableDictionary *contactData = [self emptyContactDict];
+  
+  [contactData setValue:contact.identifier forKey:@"recordId"];
+  //Return name
+  NSString *fullName = [self getFullNameForFirst:contact.givenName middle:contact.middleName last:contact.familyName ];
+  [contactData setValue:fullName forKey:@"name"];
+  [contactData setValue:contact.givenName forKey:@"givenName"];
+  [contactData setValue:contact.middleName forKey:@"middleName"];
+  [contactData setValue:contact.familyName forKey:@"familyName"];
+  
+  //Return phone numbers
+  NSMutableArray* phoneEntries = [contactData valueForKey:@"phones"];
+  for (CNLabeledValue<CNPhoneNumber*> *phone in contact.phoneNumbers) {
+    CNPhoneNumber* phoneNumber = [phone value];
+    NSString* phoneLabel = [phone label];
+    NSMutableDictionary<NSString*, NSString*>* phoneEntry = [[NSMutableDictionary alloc] initWithCapacity:2];
+    [phoneEntry setValue:[phoneNumber stringValue] forKey:@"number"];
+    [phoneEntry setValue:[CNLabeledValue localizedStringForLabel:phoneLabel] forKey:@"type"];
+    [phoneEntries addObject:phoneEntry];
+  }
+  
+  //Return email addresses
+  NSMutableArray* emailEntries = [contactData valueForKey:@"emails"];
+  for (CNLabeledValue<NSString*> *email in contact.emailAddresses) {
+    NSString* emailAddress = [email value];
+    NSString* emailLabel = [email label];
+    NSMutableDictionary<NSString*, NSString*>* emailEntry = [[NSMutableDictionary alloc] initWithCapacity:2];
+    [emailEntry setValue:emailAddress forKey:@"address"];
+    [emailEntry setValue:[CNLabeledValue localizedStringForLabel:emailLabel] forKey:@"type"];
+    [emailEntries addObject:emailEntry];
+  }
+  
+  // Return postal addresses
+  NSMutableArray* addressEntries = [contactData valueForKey:@"postalAddresses"];
+  for (CNLabeledValue<CNPostalAddress*> *postalAddress in contact.postalAddresses) {
+    CNPostalAddress* addressInfo = [postalAddress value];
+    NSMutableDictionary<NSString*, NSString*>* addressEntry = [[NSMutableDictionary alloc] init];
+    [addressEntry setValue:[addressInfo street] forKey:@"street"];
+    [addressEntry setValue:[addressInfo city] forKey:@"city"];
+    [addressEntry setValue:[addressInfo state] forKey:@"state"];
+    [addressEntry setValue:[addressInfo postalCode] forKey:@"postalCode"];
+    [addressEntry setValue:[addressInfo ISOCountryCode] forKey:@"isoCountryCode"];
+    [addressEntries addObject:addressEntry];
+  }
+  
+  self._resolve(contactData);
+}
+
+-(NSString *) getFullNameForFirst:(NSString *)fName middle:(NSString *)mName last:(NSString *)lName {
+  //Check whether to include middle name or not
+  NSArray *names = (mName.length > 0) ? [NSArray arrayWithObjects:fName, mName, lName, nil] : [NSArray arrayWithObjects:fName, lName, nil];
+  return [names componentsJoinedByString:@" "];
+}
+
+- (void)contactPickerDidCancel:(CNContactPickerViewController *)picker {
+  self._reject(@"E_CONTACT_CANCELLED", @"Cancelled", nil);
+}
+
+@end