ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.SEND_SMS}, 0);改成通讯录

如果你想请求读取通讯录的权限，你可以将代码更改为：

ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_CONTACTS}, 0);

这将请求用户授予你的应用程序读取通讯录的权限。确保在运行时请求这些权限，以便在用户同意之前不会访问通讯录。同时，你需要在AndroidManifest.xml文件中添加以下代码：

<uses-permission android:name="android.permission.READ_CONTACTS"/>

这将在安装应用程序时请求读取通讯录的权限。

相关问题

利于android实现手机通讯录App 1. 功能： （1）显示通讯录中的联系人列表，对联系人有增、删、改、查的功能； （2）选择某一联系人，可以向其发送短信和拨打电话，给出所有的完整代码

很抱歉，这里无法给出完整的代码，因为这需要很多的代码和时间。但是，我可以为你提供一个基本的框架和示例代码，以帮助你开始实现这个应用程序。

首先，你需要在Android Studio中创建一个新的项目，并添加以下权限：

<uses-permission android:name="android.permission.READ_CONTACTS" />
<uses-permission android:name="android.permission.WRITE_CONTACTS" />
<uses-permission android:name="android.permission.CALL_PHONE" />
<uses-permission android:name="android.permission.SEND_SMS" />

接下来，创建一个名为Contacts的Activity，并在布局文件中添加一个ListView，用于显示联系人列表。

<ListView
    android:id="@+id/list_view_contacts"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

然后，在Contacts Activity中添加以下代码，以获取联系人数据并将其显示在ListView中。

public class ContactsActivity extends AppCompatActivity implements AdapterView.OnItemClickListener {

    private ListView listViewContacts;
    private Cursor cursorContacts;
    private SimpleCursorAdapter adapterContacts;

    private static final String[] PROJECTION_CONTACTS = {
            ContactsContract.Contacts._ID,
            ContactsContract.Contacts.DISPLAY_NAME_PRIMARY
    };

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_contacts);

        listViewContacts = findViewById(R.id.list_view_contacts);
        listViewContacts.setOnItemClickListener(this);

        cursorContacts = getContentResolver().query(
                ContactsContract.Contacts.CONTENT_URI,
                PROJECTION_CONTACTS,
                null,
                null,
                ContactsContract.Contacts.DISPLAY_NAME_PRIMARY + " ASC"
        );

        adapterContacts = new SimpleCursorAdapter(
                this,
                android.R.layout.simple_list_item_1,
                cursorContacts,
                new String[]{ContactsContract.Contacts.DISPLAY_NAME_PRIMARY},
                new int[]{android.R.id.text1},
                0
        );

        listViewContacts.setAdapter(adapterContacts);
    }

    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
        // TODO: Handle contact item click
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (cursorContacts != null) {
            cursorContacts.close();
        }
    }
}

接下来，你需要添加菜单项，以允许用户添加、编辑和删除联系人。在Contacts Activity中添加以下代码，以显示菜单项并处理用户操作。

public boolean onCreateOptionsMenu(Menu menu) {
    getMenuInflater().inflate(R.menu.menu_contacts, menu);
    return true;
}

public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
        case R.id.menu_item_add_contact:
            // TODO: Handle add contact
            return true;
        case R.id.menu_item_edit_contact:
            // TODO: Handle edit contact
            return true;
        case R.id.menu_item_delete_contact:
            // TODO: Handle delete contact
            return true;
        default:
            return super.onOptionsItemSelected(item);
    }
}

在菜单资源文件menu_contacts.xml中添加以下代码，以定义菜单项。

<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item
        android:id="@+id/menu_item_add_contact"
        android:title="@string/menu_item_add_contact" />
    <item
        android:id="@+id/menu_item_edit_contact"
        android:title="@string/menu_item_edit_contact"
        android:enabled="false" />
    <item
        android:id="@+id/menu_item_delete_contact"
        android:title="@string/menu_item_delete_contact"
        android:enabled="false" />
</menu>

接下来，你需要添加权限请求处理程序，以确保应用程序可以访问设备上的联系人数据。

private static final int REQUEST_CODE_READ_CONTACTS = 1;

private void requestReadContactsPermission() {
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CONTACTS) != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_CONTACTS}, REQUEST_CODE_READ_CONTACTS);
    } else {
        // Permission already granted
    }
}

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    switch (requestCode) {
        case REQUEST_CODE_READ_CONTACTS:
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // Permission granted
            } else {
                // Permission denied
            }
            return;
        default:
            super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }
}

现在，你可以在Contacts Activity的onCreate方法中调用requestReadContactsPermission方法，以请求读取联系人数据的权限。

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_contacts);

    requestReadContactsPermission();

    // ...
}

接下来，你需要处理联系人项的单击事件，以允许用户拨打电话或发送短信。

private static final int REQUEST_CODE_CALL_PHONE = 2;
private static final int REQUEST_CODE_SEND_SMS = 3;

@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
    cursorContacts.moveToPosition(position);

    final String contactId = cursorContacts.getString(cursorContacts.getColumnIndex(ContactsContract.Contacts._ID));
    final String contactName = cursorContacts.getString(cursorContacts.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME_PRIMARY));

    final String[] PROJECTION_PHONE = {
            ContactsContract.CommonDataKinds.Phone.NUMBER
    };

    final Cursor cursorPhone = getContentResolver().query(
            ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
            PROJECTION_PHONE,
            ContactsContract.CommonDataKinds.Phone.CONTACT_ID + " = ?",
            new String[]{contactId},
            null
    );

    final List<String> phoneNumbers = new ArrayList<>();

    while (cursorPhone.moveToNext()) {
        final String phoneNumber = cursorPhone.getString(cursorPhone.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
        phoneNumbers.add(phoneNumber);
    }

    cursorPhone.close();

    final String[] PROJECTION_EMAIL = {
            ContactsContract.CommonDataKinds.Email.ADDRESS
    };

    final Cursor cursorEmail = getContentResolver().query(
            ContactsContract.CommonDataKinds.Email.CONTENT_URI,
            PROJECTION_EMAIL,
            ContactsContract.CommonDataKinds.Email.CONTACT_ID + " = ?",
            new String[]{contactId},
            null
    );

    final List<String> emailAddresses = new ArrayList<>();

    while (cursorEmail.moveToNext()) {
        final String emailAddress = cursorEmail.getString(cursorEmail.getColumnIndex(ContactsContract.CommonDataKinds.Email.ADDRESS));
        emailAddresses.add(emailAddress);
    }

    cursorEmail.close();

    final AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setTitle(contactName);
    builder.setItems(new CharSequence[]{"Call", "Send SMS"}, new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {
            switch (which) {
                case 0:
                    if (ContextCompat.checkSelfPermission(ContactsActivity.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
                        ActivityCompat.requestPermissions(ContactsActivity.this, new String[]{Manifest.permission.CALL_PHONE}, REQUEST_CODE_CALL_PHONE);
                    } else {
                        final Intent intentCall = new Intent(Intent.ACTION_CALL);
                        intentCall.setData(Uri.parse("tel:" + phoneNumbers.get(0)));
                        startActivity(intentCall);
                    }
                    break;
                case 1:
                    if (ContextCompat.checkSelfPermission(ContactsActivity.this, Manifest.permission.SEND_SMS) != PackageManager.PERMISSION_GRANTED) {
                        ActivityCompat.requestPermissions(ContactsActivity.this, new String[]{Manifest.permission.SEND_SMS}, REQUEST_CODE_SEND_SMS);
                    } else {
                        final Intent intentSms = new Intent(Intent.ACTION_SENDTO);
                        intentSms.setData(Uri.parse("smsto:" + phoneNumbers.get(0)));
                        startActivity(intentSms);
                    }
                    break;
            }
        }
    });
    builder.show();
}

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    switch (requestCode) {
        case REQUEST_CODE_CALL_PHONE:
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                final Intent intentCall = new Intent(Intent.ACTION_CALL);
                intentCall.setData(Uri.parse("tel:" + phoneNumbers.get(0)));
                startActivity(intentCall);
            }
            break;
        case REQUEST_CODE_SEND_SMS:
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                final Intent intentSms = new Intent(Intent.ACTION_SENDTO);
                intentSms.setData(Uri.parse("smsto:" + phoneNumbers.get(0)));
                startActivity(intentSms);
            }
            break;
        default:
            super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }
}

最后，你需要添加以下代码，以确保在Contacts Activity销毁时关闭游标。

@Override
protected void onDestroy() {
    super.onDestroy();
    if (cursorContacts != null) {
        cursorContacts.close();
    }
}

这些代码可以帮助你实现一个基本的Android手机通讯录App，但是你需要根据需求进行更多的定制和优化。

Android studio中写一个用contentResolver()方法实现读取通讯录并功能实现发短信和打电话的代码

以下是一个使用contentResolver()方法实现读取通讯录并实现发短信和打电话功能的示例代码：

public class MainActivity extends AppCompatActivity {

    private static final int READ_CONTACTS_PERMISSIONS_REQUEST = 1;
    private static final int REQUEST_SEND_SMS = 2;
    private static final int REQUEST_CALL_PHONE = 3;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CONTACTS)
                != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this,
                    new String[]{Manifest.permission.READ_CONTACTS},
                    READ_CONTACTS_PERMISSIONS_REQUEST);
        } else {
            readContacts();
        }
    }

    private void readContacts() {
        String[] projection = new String[]{ContactsContract.Contacts.DISPLAY_NAME,
                ContactsContract.CommonDataKinds.Phone.NUMBER};
        String sortOrder = ContactsContract.Contacts.DISPLAY_NAME + " ASC";

        Cursor cursor = getContentResolver().query(
                ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
                projection,
                null,
                null,
                sortOrder);

        if (cursor != null && cursor.getCount() > 0) {
            while (cursor.moveToNext()) {
                String name = cursor.getString(0);
                String phone = cursor.getString(1);
                Log.d("Contacts", name + " - " + phone);
            }
            cursor.close();
        }
    }

    public void sendMessage(String phoneNumber, String message) {
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.SEND_SMS)
                != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this,
                    new String[]{Manifest.permission.SEND_SMS},
                    REQUEST_SEND_SMS);
        } else {
            SmsManager smsManager = SmsManager.getDefault();
            smsManager.sendTextMessage(phoneNumber, null, message, null, null);
            Toast.makeText(this, "Message sent successfully", Toast.LENGTH_SHORT).show();
        }
    }

    public void callPhoneNumber(String phoneNumber) {
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE)
                != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this,
                    new String[]{Manifest.permission.CALL_PHONE},
                    REQUEST_CALL_PHONE);
        } else {
            Intent callIntent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:" + phoneNumber));
            startActivity(callIntent);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == READ_CONTACTS_PERMISSIONS_REQUEST) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                readContacts();
            }
        } else if (requestCode == REQUEST_SEND_SMS) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // Permission granted, send SMS
                sendMessage("1234567890", "Hello, world!");
            }
        } else if (requestCode == REQUEST_CALL_PHONE) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // Permission granted, call phone
                callPhoneNumber("1234567890");
            }
        }
    }
}

在这个示例代码中，`readContacts()`方法使用`contentResolver()`方法读取通讯录，并将结果输出到Logcat中。`sendMessage()`方法使用`SmsManager`类发送短信。`callPhoneNumber()`方法使用`Intent.ACTION_CALL`和`Uri.parse()`来拨打电话。在`onRequestPermissionsResult()`方法中，我们检查用户是否授予了所需的权限，并在授予权限后执行相应的操作。请注意，这些权限请求的响应代码已在示例代码中定义。