Android发送短信和读取联系人

最新推荐文章于 2021-03-14 23:07:26 发布

讠午月月鸟

最新推荐文章于 2021-03-14 23:07:26 发布

阅读量854

点赞数 1

分类专栏：我的学习笔记

本文链接：https://blog.csdn.net/flyingfox023/article/details/19448943

版权

我的学习笔记专栏收录该内容

7 篇文章 0 订阅

订阅专栏

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;
    }
}