Android发送短信和读取联系人

http://wanglihu.iteye.com/blog/1329693（汉字转换为拼音）

一，发短信

package com.example.smsdemo;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class MainActivity extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button btn=(Button) findViewById(R.id.btn);
btn.setOnClickListener(new OnClickListener() {

@Override
public void onClick(View v) {
//				sendSmsWithNumber(MainActivity.this, "13983772334");
sendSmsWithBody(MainActivity.this, "13983772334","xxoo");
}
});
}

/**
* 调用系统界面，给指定的号码发送短信
*
* @param context
* @param number
*/
public void sendSmsWithNumber(Context context, String number) {
Intent sendIntent = new Intent(Intent.ACTION_SENDTO, Uri.parse("smsto:" + number));
context.startActivity(sendIntent);
}
/**
* 调用系统界面，给指定的号码发送短信，并附带短信内容
*
* @param context
* @param number
* @param body
*/
public void sendSmsWithBody(Context context, String number, String body) {
Intent sendIntent = new Intent(Intent.ACTION_SENDTO);
sendIntent.setData(Uri.parse("smsto:" + number));
sendIntent.putExtra("sms_body", body);
context.startActivity(sendIntent);
}
}

二、读取联系人

package com.example.contactsdemo;

import android.app.Activity;
import android.content.ContentResolver;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.provider.Contacts.People.Phones;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ListView;
import android.widget.TextView;

public class MainActivity extends Activity {

private ListView lv;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
readRowContacts();
lv = (ListView) findViewById(R.id.lv);
lv.setAdapter(new MyAdapter());
}

private Uri rawContactsUri = Uri
.parse("content://com.android.contacts/raw_contacts");
private Uri dataUri = Uri.parse("content://com.android.contacts/data");
private ContentResolver resolver;
private Cursor rawContactsCursor;

public void readRowContacts() {
resolver = getContentResolver();
rawContactsCursor = resolver.query(rawContactsUri,
new String[] { "_id" }, "contact_id IS NOT NULL", null, null);

}

class MyAdapter extends BaseAdapter {

@Override
public int getCount() {
return rawContactsCursor.getCount();
}

@Override
public Object getItem(int position) {
return null;
}

@Override
public long getItemId(int position) {
return 0;
}

@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder = null;
View v;
if (convertView == null) {
v = View.inflate(MainActivity.this, R.layout.item_contacts,
null);
holder = new ViewHolder();
holder.tv_name = (TextView) v.findViewById(R.id.tv_name);
holder.tv_number = (TextView) v.findViewById(R.id.tv_number);
v.setTag(holder);
} else {
v = convertView;
}
holder = (ViewHolder) v.getTag();
if (rawContactsCursor.moveToNext()) {
long id = rawContactsCursor.getLong(0); // 获取每一个id
Cursor dataCursor = resolver.query(dataUri, new String[] {
"mimetype", "data1" }, "raw_contact_id=" + id, null,
null);
while (dataCursor.moveToNext()) { // 获取每个联系人的数据
String type = dataCursor.getString(0); // 数据类型
String data = dataCursor.getString(1); // 数据值
if ("vnd.android.cursor.item/phone_v2".equals(type))
holder.tv_number.setText(data);
if ("vnd.android.cursor.item/name".equals(type))
holder.tv_name.setText(data);
}
}
return v;
}

}

class ViewHolder {
TextView tv_name;
TextView tv_number;
}
}

三、pinyin4j的基本用法

1. 简单介绍

有时候，需要将汉字编程对应的拼音，以方便数据的处理。比如在Android手机应用的开发上，要查询联系人的姓名，通常都是用拼音进行查询的。比如要查询“曹孟德”，就可以输入“cmd”，即“曹孟德”三个汉字的拼音“caomengde”各字的首字母。但是怎样才能将“曹孟德”翻译成“caomengde”呢？很简单的办法就是建立一个大的对照表(比如用关联容器Map)，比如<”曹”，”cao”>，<” 孟”，”meng”>，<” 德”，”de”>…但这样的做法，需要维护好一个比较大的对照表，同时一个汉字可能有多个发音，也就是说Map这样的容器时不行的，因为其<key,value>必须是一一对应的。在C++中可以用STL里面的multimap来解决这个问题，但Java中没有类似multimap这样的东西，除非自己实现一个。

Pinyin4j就是为了解决类似这样的问题的。它是sourceforge.net上的一个开源项目，功能非常强大：

+ 支持同一汉字有多个发音

+ 还支持拼音的格式化输出，比如第几声之类的，

+ 同时支持简体中文、繁体中文转换为拼音…使用起来也非常简单。下面是其官方网址，其中提供了下载：

http://pinyin4j.sourceforge.net/

2. 基本用法：

通常情况下，只需要用到其中的PinyinHelper类中的静态方法toHanyuPinyinStringArray就可以了，比如：

String[] pinyinArray =PinyinHelper.toHanyuPinyinStringArray('单');

for(int i = 0; i < pinyinArray.length; ++i)

{

System.out.println(pinyinArray[i]);

}

就会输出：

dan1

chan2

shan4

这三种发音，后面的数字代表第几声。可以看到静态方法toHanyuPinyinStringArray返回的数据类型是一个String数组，它用来接收一个汉字的多个发音，如果toHanyuPinyinStringArray中的参数不是汉字，那么它会返回null。

3. 格式支持

Pinyin4j支持拼音输出的格式化，比如，“黄”可以输出为“huang”、“huang2”、“huáng”等等，下面的代码就似是输出“huáng”的示例：

HanyuPinyinOutputFormat format= new HanyuPinyinOutputFormat();

format.setToneType(HanyuPinyinToneType.WITH_TONE_MARK);

format.setVCharType(HanyuPinyinVCharType.WITH_U_UNICODE);

String[] pinyinArray = null;

try

{

pinyinArray = PinyinHelper.toHanyuPinyinStringArray('黄', format);

}

catch(BadHanyuPinyinOutputFormatCombination e)

{

e.printStackTrace();

}

for(int i = 0; i < pinyinArray.length; ++i)

{

System.out.println(pinyinArray[i]);

}

此外，还支持大小写转换、ü等等。详细情况，可以查看Pinyin4j自带的文档。

4. 实际示例代码

如果我们要将一段文字中的汉字全部转换成不带音调的拼音输出，而这段文字中又可能包含阿拉伯数字、英文、标点符号等等。如果完全靠自己写代码进行转换，那是非常麻烦的，其中一个首先就要区别，这段文字中那些是汉字，那些是非汉字。有了Pinyin4j，这个问题就不再困难了，因为对于非汉字，Pinyin4j会自动输出null。参考下面的示例代码：

importnet.sourceforge.pinyin4j.*;

importnet.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;

importnet.sourceforge.pinyin4j.format.HanyuPinyinToneType;

importnet.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;

public class Chinese2PY

{

public static void main(String[] args)

{

Hanyu hanyu = new Hanyu();

// 中英文混合的一段文字

String str = "荆溪白石出，Hello 天寒红叶稀。Android 山路元无雨，What's up? 空翠湿人衣。";

String strPinyin = hanyu.getStringPinYin(str);

System.out.println(strPinyin);

}

}

class Hanyu

{

private HanyuPinyinOutputFormat format = null;

private String[] pinyin;

public Hanyu()

{

format = new HanyuPinyinOutputFormat();

format.setToneType(HanyuPinyinToneType.WITHOUT_TONE);

pinyin = null;

}

//转换单个字符

public String getCharacterPinYin(char c)

{

try

{

pinyin = PinyinHelper.toHanyuPinyinStringArray(c, format);

}

catch(BadHanyuPinyinOutputFormatCombination e)

{

e.printStackTrace();

}

// 如果c不是汉字，toHanyuPinyinStringArray会返回null

if(pinyin == null) return null;

// 只取一个发音，如果是多音字，仅取第一个发音

return pinyin[0];

}

//转换一个字符串

public String getStringPinYin(String str)

{

StringBuilder sb = new StringBuilder();

String tempPinyin = null;

for(int i = 0; i < str.length(); ++i)

{

tempPinyin =getCharacterPinYin(str.charAt(i));

if(tempPinyin == null)

{

// 如果str.charAt(i)非汉字，则保持原样

sb.append(str.charAt(i));

}

else

{

sb.append(tempPinyin);

}

}

return sb.toString();

}

}

输出结果：

jingxibaishichu，Hellotianhanhongyexi。Android shanluyuanwuyu，What'sup? kongcuishirenyi。

四、多重排序

关键代码

public void testPinyin() {
// HanyuPinyinOutputFormat format = new HanyuPinyinOutputFormat();
// format.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
// format.setVCharType(HanyuPinyinVCharType.WITH_U_UNICODE);
// try {
// PinyinHelper.toHanyuPinyinStringArray('单', format);
// } catch (BadHanyuPinyinOutputFormatCombination e) {
// e.printStackTrace();
// }
// String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray('单');
//
// for (int i = 0; i < pinyinArray.length; ++i)
//
// {
//
// Log.i("pinyin4j", pinyinArray[i]);
//
// }

Hanyu hanyu = new Hanyu();

// 中英文混合的一段文字

String str = "荆溪白石出，Hello 天寒红叶稀。Android 山路元无雨，What's up?   空翠湿人衣。";

String strPinyin = hanyu.getStringPinYin(str);

System.out.println(strPinyin);
Log.i("pinyin4j", strPinyin);

}

public void testSort() {
ArrayList<ContactsInfo> list=new ArrayList<ContactsInfo>(){
{
add(new ContactsInfo("aa", "134354", 1));
add(new ContactsInfo("ac", "134354", 1));
add(new ContactsInfo("ab", "134354", 1));
add(new ContactsInfo("ba", "134354", 0));
add(new ContactsInfo("bc", "134354", 0));
add(new ContactsInfo("bb", "134354", 0));
add(new ContactsInfo("ab", "1343548888", 1));
}
};

System.out.println(list.toString());
// SortUtil.sort(list, "type#1","name#2");
Collections.sort(list, new Comparator<ContactsInfo>() {

@Override
public int compare(ContactsInfo a1, ContactsInfo a2) {
int cr = 0;
int a = a2.getType() - a1.getType();
if (a != 0)
cr = (a < 0) ? 3 : -1;
else {
a = a2.getName().compareToIgnoreCase(a1.getName());
if (a != 0)
cr = (a < 0) ? 2 : -2;
else {
a = (int) (a2.getNumber().compareToIgnoreCase(a1.getNumber()));
if (a != 0)
cr = (a < 0) ? 1 : -3;
}
}
return cr;
}
});
Log.i("pinyin4j", list.toString());

// String[] ary = { "test", "abc", "apple", "PEar" };
// System.out.println("Before sorted, the array is: "
// + Arrays.toString(ary));
// Arrays.sort(ary);
// System.out.println("After sorted, the new array is: "
// + Arrays.toString(ary));

// ArrayList<HashMap<String,String>> list = new
// ArrayList<HashMap<String,String>>();
// HashMap<String,String> map1=new HashMap<String, String>();
// map1.put("city", "zhongguo");
// map1.put("number", "010");
// HashMap<String,String> map2=new HashMap<String, String>();
// map2.put("city", "henan");
// map2.put("number", "0371");
// HashMap<String,String> map3=new HashMap<String, String>();
// map3.put("city", "anhui");
// map3.put("number", "0731");
// list.add(map1);
// list.add(map2);
// list.add(map3);
// Collections.sort(list, new Realize_Comparator());//
// 根据第二个参数,即排序器的规定进行排序,应用起来更灵活
// Collections.sort(list);//根据元素的自然顺序 对指定列表按升序进行排序。
// for (int i = 0; i < list.size(); i++) {
// System.out.println(list.get(i).get("city"));
//
// }

}

public class ContactsInfo {
private String name;
private String number;
private int type;
public ContactsInfo(String name, String number, int type) {
super();
this.name = name;
this.number = number;
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
@Override
public String toString() {
return "ContactsInfo [name=" + name + ", number=" + number + ", type="
+ type + "]";
}

}

class Realize_Comparator implements Comparator<Map<String, String>> {

@Override
public int compare(Map<String, String> lhs, Map<String, String> rhs) {
return lhs.get("city").compareToIgnoreCase(rhs.get("city"));

}

}

通用的多重排序比较器，效果待测……

package util;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
* 排序类，通用于获取的对象的方法值 都是int类型
*
* @author chenjy
*
*/
public final class SortUtil {
/**
* 装载已经用过的规则 实现类似单例模式
*/
private static Map<String, SortUtil> sortMap = new HashMap<String, SortUtil>();

private Method[] methodArr = null;
private int[] typeArr = null;

/**
* 构造函数 并保存该规则
*
* @param clazz
* @param args
*/
private <T> SortUtil(Class<T> clazz, String... args) {
methodArr = new Method[args.length];
typeArr = new int[args.length];
for (int i = 0; i < args.length; i++) {
String key = args[i].split("#")[0];
try {
methodArr[i] = clazz.getMethod(key, new Class[] {});
typeArr[i] = Integer.valueOf(args[i].split("#")[1]);
} catch (Exception e1) {
e1.printStackTrace();
}
}
}

/**
* 排序规则
*
* @author chenjy 2012-03-13
*/
private Comparator<Object> comparator = new Comparator<Object>() {
@Override
public int compare(Object o1, Object o2) {
for (int i = 0; i < methodArr.length; i++) {
try {
Object value1 = methodArr[i].invoke(o1);
Object value2 = methodArr[i].invoke(o2);
double double1 = 0;
double double2 = 0;

if (value1 instanceof Integer) {
double1 = (Integer) value1;
double2 = (Integer) value2;
} else if (value1 instanceof Boolean) {
double1 = (Boolean) value1 ? 1 : -1;
double2 = (Boolean) value2 ? 1 : -1;
} else if (value1 instanceof Double) {
double1 = (Double) value1;
double2 = (Double) value2;
} else if (value1 instanceof Float) {
double1 = (Float) value1;
double2 = (Float) value2;
} else if (value1 instanceof Long) {
double1 = (Long) value1;
double2 = (Long) value2;
} else {
double1 = value1.toString().compareToIgnoreCase(
value2.toString());
double2 = -double1;
}
if (double1 == double2) {
continue;
}
if (typeArr[i] == 1) {
return (double1 > double2) ? 1 : -1;
} else {
return (double1 > double2) ? -1 : 1;
}
} catch (Exception e1) {
e1.printStackTrace();
}
}
return 0;
}
};

/**
* 获取排序规则 2012-3-13
*
* @return SortUtil
* @author chenjy
*/
private static <T> SortUtil getSort(Class<T> clazz, String... args) {
String key = clazz.getName() + Arrays.toString(args);
if (sortMap.containsKey(key)) {
return sortMap.get(key);
} else {
SortUtil sort = new SortUtil(clazz, args);
sortMap.put(key, sort);
return sort;
}
}

/**
* <pre>
* 首先会在容器中，根据class+规则去找。如果没有见则new
* 调用方式 SortUtil.sort(list,"方法名#升序(1)/降序(-1)","..","..")
* 后面字符串参数：比如："getMark#1","getAge#-1"
* 表示先按照getMark的值按照升序排，如果相等再按照getAge的降序排
* 如果返回值是true类型，若按照true先排："isOnline#1" ,若按照false先排："isOnline#-1"
* </pre>
*
* @author chenjy 2012-3-13
* @param list
* @param args
*/
public static <T> void sort(List<T> list, String... args) {
if (list == null || list.size() == 0 || args.length == 0) {
return;
}
SortUtil sort = getSort(list.get(0).getClass(), args);
Collections.sort(list, sort.comparator);
}

/**
* 给Map进行排序 对map的value进行排序
*
* @author chenjy 2012-3-13
* @param map
*            被排序的map
* @param args
*            排序方法条件：方法名x#1升序-1倒序, 方法名y#-1倒序
* @return List<T>
*/
public static <T, F> List<F> sortMap(Map<T, F> map, String... args) {
List<F> list = new ArrayList<F>();
if (map == null || map.isEmpty()) {
return list;
}
list.addAll(map.values());
sort(list, args);
return list;
}
}