Runtime.getRuntime().exec("pm install xxx.apk"); 

1.      /** 
2.      * 安装apk 
3.      * @param url 
4.      */  
5.     private void installApk(){  
6.         File apkfile = new File(saveFileName);  
7.         if (!apkfile.exists()) {  
8.             return;  
9.         }      
10.         Intent i = new Intent(Intent.ACTION_VIEW);  
11.         i.setDataAndType(Uri.parse("file://" + apkfile.toString()), "application/vnd.android.package-archive");   
12.         mContext.startActivity(i);  
13. }

   private boolean isAppInstalled(String uri){
    	
    	PackageManager pm = getPackageManager();
    	boolean installed =false;
    	try{
    		pm.getPackageInfo(uri,PackageManager.GET_ACTIVITIES);
    		installed =true;
    	}catch(PackageManager.NameNotFoundException e){
    		installed =false;
    	}
    	
    	return installed;
    } 

屏常亮（camera中的代码）

private void setBT(boolean enable) {
		// TODO Auto-generated method stub
		
		if (btAdapter == null) {
			//btadapter = BluetoothAdapter.getDefaultAdapter();
			Log.d("jimbo", "not support bluetooth");
		} else {
			if (enable) {
				btAdapter.enable();
			} else {
				btAdapter.disable();
			}
			IntentFilter intentFilterBt = new IntentFilter();
			intentFilterBt.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
			intentFilterBt.addAction(BluetoothDevice.ACTION_FOUND);
			intentFilterBt.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
			intentFilterBt.addAction(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED);
			intentFilterBt.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
			registerReceiver(mBtStateReceiver , intentFilterBt);
			
			btAdapter.startDiscovery();
			
		}
	}

 回到待机界面

    public static boolean shouldEnableScreenRotation(Context context) {
        ///M: when is alarm boot,disable rotation @{
        if (PowerOffAlarmManager.isAlarmBoot()) {
            return false;
        } 
        ///@}
        return SystemProperties.getBoolean("lockscreen.rot_override",false)
                || context.getResources().getBoolean(R.bool.config_enableLockScreenRotation);
    }

lockscreen.rot_override=true

</pre></div><h3>设置(Settings)<span style="background-color:#ff9632">默认</span>值</h3><p>frameworks/base/packages/SettingsProvider/src/com/Android/providers/settings/DatabaseHelper.java</p><p>loadIntegerSetting(stmt, Settings.System.SCREEN_OFF_TIMEOUT, R.integer.def_screen_off_timeout);</p><p>R.integer.def_screen_off_timeout来初始化。我们为了让系统永不锁屏，只需要把资源 R.integer.def_screen_off_timeout设为-1即可。查看文件</p><p>frameworks\base\packages\SettingsProvider\res\values\defaults.xml  设置里面的<span style="background-color:#ffd700">默认</span>值  例：def_screen_off_timeout  <span style="background-color:#ffd700">默认</span>锁屏时间frameworks\base\packages\SettingsProvider\src\com\android\providers\settings\DatabaseHelper.java  函数loadSystemSettings(SQLiteDatabase db) 加载各个<span style="background-color:#ffd700">默认</span>值SoundSettings.java mDtmfToneDefaultValue<span style="background-color:#ffd700">默认</span>按键音</p><p>开机<span style="background-color:#ffd700">默认</span>锁屏 ：</p><p>frameworks/policies/base/phone/com/Android/internal/policy/impl/KeyguardViewMediator.java该文件中有一个变量定义如下：    /**     * External apps (like the phone app) can tell us to disable the keygaurd.     */    private boolean mExternallyEnabled = true;mExternallyEnabled是用来管理是否开启屏幕锁的关键。<span style="background-color:#ffd700">默认</span>值是打开屏锁       </p><p>默认时间格式： </p><p>DateFormat.java  is24HourFormat（）</p><p>android源码是根据地区自适应选择是24小时还是12小时</p><p>代码：</p><pre code_snippet_id="76283" snippet_file_name="blog_20131121_3_7535774" class="java" name="code"> if (value =http://www.mamicode.com/= null) {>
}

如果要去掉自适应，可以修改
java.text.DateFormat.LONG, locale); ->java.text.DateFormat.LONG, Locale.UK);    //24小时格式
java.text.DateFormat.LONG, locale); ->java.text.DateFormat.LONG, Locale.US.);    //12小时格式
修改默认时间
mtk中默认时间设置：
\alps\mediatek\custom\[project]\preloader\ inc\cust_rtc.h
\alps\mediatek\custom\[project]\kernel\rtc\rtc\rtc-mt65XX.h
 
#define RTC_DEFAULT_YEA         2010
#define RTC_DEFAULT_MTH        1
#define RTC_DEFAULT_DOM        1
也可以在kernel中使用代码设置时间
（在android中，Linux内核中、rtc时钟，默认的起始日期都是1970年1月1日，那么如何把默认日期指到2012-01-01呢？笔者在实践中发现，在RTC驱动中可以很容易实现。在RTC驱动加载的时候，一般都有个probe函数需要先执行，因此在probe函数里下手最直接有效。RTC从1970-01-01开始，那当然很容易把默认值设置到2012-01-01，所需要设置的seconds也就是从1970-01-01所差的秒数，以秒为单位。因此，一旦读出来的RTC值小于我们预想的值比如2012-01-01（1325402913）小，我们就把它设置到这个时间点。）
seconds = rtc_read_time();  
printk("init PMU/RTC time to  %ld \n", seconds);  
  
if(seconds <= 1325402913) {  
    seconds = 1325402913;/*2012-01-01*/  
    ret = rtc_set_time(seconds);  
    RTC_DBG("Init Set time: %ld, ret =0x%x\n", seconds, ret);  
}
java 24小时格式显示转换
在使用SimpleDateFormat时格式化时间的 yyyy.MM.dd 为年月日而如果希望格式化时间为12小时制的，则使用hh:mm:ss 如果希望格式化时间为24小时制的，则使用HH:mm:ss 
Date d = new Date();  
SimpleDateFormat ss = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//12小时制   
System.out.println(ss.format(d));  
  
Date date = new Date();  
SimpleDateFormat sdformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//24小时制   
String LgTime = sdformat.format(date);  
System.out.println(LgTime);  
xml 字符串中特殊字符& 、<、>、 ‘、" 的处理
& 使用&amp; 代替                  ‘ 使用\‘ 代替‘
 &lt; < 小于号
&gt; > 大于号
&amp; & 和
&apos; ‘ 单引号
&quot; " 双引号

<b></b>加粗字体 
<i></i> 斜体字体 
<u></u> 给字体加下划线 
\n 换行 
\u0020表示空格 
\u2026表示省略号 
使用&lt;b>和&lt;b>来打印出<b></b> 这样的文字；“&lt;”表示“<”的意思； 
使用textView.setText(Html.fromHtml("Hello <b>World</b>,<font size=\"3\" color=\"red\">AnalysisXmlActivty!</font>"));设置类似于html那样的效果 
如果你需要使用 String.format(String, Object...) 来格式化你的字符串，你可以把格式化参数放在你的字符串中，参见下面的例子： 
<string name="welcome_messages">Hello, %1$s! You have %2$d new messages.</string> 
在这个例子中，这个格式化的字符串有2个参数， %1$s是个字符串 %2$d 是个浮点数，你可以在你的程序中按照下面的方法来根据参数来格式化字符串： 
Resources res = getResources(); 
String text = String.format(res.getString(R.string.welcome_messages), username, mailCount); 
那么根据例子上说的我需要把%s换成%1$s才行了，修改后编译通过，程序成功启动。 
问题补充：如何在<string></string>中使用%号 
有两个办法可供选择 
1.用%%来表示1个%，和转意符号 \ 的用法相同 
2.如果你的字符串不需要格式化，可以在你的<string 标签上增加一个属性:formatted="false"例如 <string name="test" formatted="false">% test %</string> 即可 

开机后特定的时间内自动发送短信 
StartCromeSendMsgReceiver.java
public class StartCromeSendMsgReceiver extends BroadcastReceiver {
    private TelephonyManager mTelephonyManager;
    private Context mContext = null;
private String mImeiStr = null;
   private static final int SEND_SMS_MESSAGE_WHAT = 0x100; 
private final Timer mSendSmsTimer = new Timer();
private TimerTask mSendSmsTask = null;
@Override
public void onReceive(Context arg0, Intent arg1) {
// TODO Auto-generated method stub
mContext = arg0;
if(arg1.getAction().equals( Intent.ACTION_BOOT_COMPLETED )) {
                   //延时时间 1小时start
mSendSmsTask = new TimerTask() {
@Override
public void run() {
// TODO Auto-generated method stub
if(!isSendSmsFlagExist()){
Message message = mSendSmsHandler.obtainMessage();
message.what = SEND_SMS_MESSAGE_WHAT;
mSendSmsHandler.sendMessage(message);
}
}
};

// start timer
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub

long delayTimer = 60*1000; //60*60*1000;  //延时时间 1小时
mSendSmsTimer.schedule(mSendSmsTask, delayTimer, delayTimer);
}
}).start();
                   //延时时间 1小时end

                   //获取IMEI 号   start
StringBuffer imeiBuffer = new StringBuffer();
int phoneCnt = TelephonyManager.getPhoneCount();

for (int i = 0; i < phoneCnt; i++) {
if(phoneCnt<2)
{ 
   imeiBuffer.append("IMEI:");
}
else
{
   imeiBuffer.append("IMEI");
   imeiBuffer.append((i + 1));
   imeiBuffer.append(":");
}

imeiBuffer.append(((TelephonyManager) arg0.getSystemService(PhoneFactory
.getServiceName(Context.TELEPHONY_SERVICE, i))).getDeviceId());

if(i < (phoneCnt-1))
{
   imeiBuffer.append("-");
}
}

mImeiStr = imeiBuffer.toString();
Log.d("StartCromeSendMsgReceiver", "+++++zhangyong[imeiStr]++++++ " + mImeiStr);
                   //获取IMEI 号   end
}
else if (SEND_SMS.equals(arg1.getAction())) {
log(SEND_SMS);
//createSendSmsFlag();
}else if(DELIVERY_SMS.equals(arg1.getAction())) {
log(DELIVERY_SMS);
if(createSendSmsFlag()){
mSendSmsTimer.cancel();
}
}
}
private void log(String msg) {
// TODO Auto-generated method stub
Log.d("StartCromeSendMsgReceiver", "--"+msg+"--");
}
private Handler mSendSmsHandler = new Handler() {
   @Override
   public void handleMessage(Message msg) {
       // TODO Auto-generated method stub
       // send sms
    switch (msg.what) {
case SEND_SMS_MESSAGE_WHAT:
sendImeiSms();
break;
default:
break;
}
   }
};
    
    private static final String DELIVERY_SMS = "delivery_sms_ok"; 
    private static final String SEND_SMS = "send_sms_ok"; 
    private static final String SEND_SMS_KEY = "has_send_sms"; 
  
private boolean createSendSmsFlag(){
boolean ret = false;
SharedPreferences preferences = mContext.getSharedPreferences("SEND_SMS_FLAG", Context.MODE_PRIVATE);

Editor editor = preferences.edit();
editor.putBoolean(SEND_SMS_KEY, true);
ret = editor.commit();

return ret;
}
private boolean isSendSmsFlagExist(){
boolean ret = false;
SharedPreferences preferences = mContext.getSharedPreferences("SEND_SMS_FLAG",Context.MODE_PRIVATE);
ret = preferences.getBoolean(SEND_SMS_KEY, false);
if(ret){
mSendSmsTimer.cancel();
}
return ret;
}
private void sendImeiSms(){
if(isSendSmsFlagExist()){
return;
}

//String sendingTextString = "测试文本！";
SmsManager sm = SmsManager.getDefault();
PendingIntent sendIntent = PendingIntent.getBroadcast(
mContext, 0,
new Intent(SEND_SMS),0);
PendingIntent deliveryIntent = PendingIntent.getBroadcast(
mContext, 0,
                new Intent(DELIVERY_SMS),0);
// new Intent(this, FullBlackActivity.class),0);

// 如果短信没有超过限制长度，则返回一个长度的List。
List<String> texts = sm.divideMessage(mImeiStr);
for (String text : texts) {
//sms.sendTextMessage(“这里是接收者电话号码”,  “这里是发送者电话号码”,  “这里是短信内容”,  null, null);
sm.sendTextMessage("15988888888", "", text, null, deliveryIntent);
//log(text);
}
}
}
然后在 AndroidManifest.xml文件中 增加
<receiver android:name=".StartCromeSendMsgReceiver">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED"/>
<action android:name="send_sms_ok"/>
<action android:name="delivery_sms_ok"/>
</intent-filter>
</receiver>
拨号：
直接在adb中 拨号： am start -a android.intent.action.CALL -d tel:10086
Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:" + "112")); 
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);  

定时器相关
一、采用Handler与线程的sleep(long)方法
二、采用Handler的postDelayed(Runnable, long)方法
三、采用Handler与timer及TimerTask结合的方法
四、闹钟定时
下面逐一介绍：
一、采用Handle与线程的sleep(long)方法
Handler主要用来处理接受到的消息。这只是最主要的方法，当然Handler里还有其他的方法供实现，有兴趣的可以去查API，这里不过多解释。
1. 定义一个Handler类，用于处理接受到的Message。
Handler handler = new Handler() {
    public void handleMessage(Message msg) {
        // 要做的事情
        super.handleMessage(msg);
    }
};
2. 新建一个实现Runnable接口的线程类，如下：
public class MyThread implements Runnable {
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            try {
                Thread.sleep(10000);// 线程暂停10秒，单位毫秒
                Message message = new Message();
                message.what = 1;
                handler.sendMessage(message);// 发送消息
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
3. 在需要启动线程的地方加入下面语句：
new Thread(new MyThread()).start();
4. 启动线程后，线程每10s发送一次消息。
二、采用Handler的postDelayed(Runnable, long)方法
这个实现比较简单一些。
1. 定义一个Handler类
Handler handler=new Handler();
Runnable runnable=new Runnable() {
    @Override
    public void run() {
        // TODO Auto-generated method stub
        //要做的事情
        handler.postDelayed(this, 2000);
    }
};
2. 启动计时器
handler.postDelayed(runnable, 2000);//每两秒执行一次runnable.
3. 停止计时器
handler.removeCallbacks(runnable);
三、采用Handler与timer及TimerTask结合的方法
1. 定义定时器、定时器任务及Handler句柄
private final Timer timer = new Timer();
private TimerTask task;
Handler handler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        // TODO Auto-generated method stub
        // 要做的事情
        super.handleMessage(msg);
    }
};
2. 初始化计时器任务
task = new TimerTask() {
    @Override
    public void run() {
        // TODO Auto-generated method stub
        Message message = new Message();
        message.what = 1;
        handler.sendMessage(message);
    }
};
3. 启动定时器
timer.schedule(task, 2000, 2000);
简要说一下上面三步提到的一些内容：
1. 定时器任务（TimerTask）顾名思义，就是说当定时器到达指定的时间时要做的工作，这里是想Handler发送一个消息，由Handler类进行处理。
2. java.util.Timer.schedule(TimerTask task, long delay):这个方法是说，dalay/1000秒后执行task.只执行一次。
java.util.Timer.schedule(TimerTask task, long delay, long period)：这个方法是说，delay/1000秒后执行task,然后进过period/1000秒再次执行task，这个用于循环任务，执行无数次，当然，你可以用timer.cancel();取消计时器的执行。
四、闹钟定时
AlarmManager am = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext, 0, new Intent(SEND_SMS_BEGIN), 0);
am.set(AlarmManager.RTC_WAKEUP, 60*1000, pendingIntent); 
android.mk 编译选项
definitions.mk    定义各类函数 例： define my-dir   define all-makefiles-under     define all-subdir-makefiles   define all-java-files-under
build/core/config.mk  各类变量的定义   例： BUILD_PACKAGE:= $(BUILD_SYSTEM)/package.mk   BUILD_STATIC_LIBRARY:= $(BUILD_SYSTEM)/static_library.mk  BUILD_SHARED_LIBRARY:= $(BUILD_SYSTEM)/shared_library.mk
耳机状态
private static final String HEADSET_STATE_PATH = "/sys/class/switch/h2w/state";    保存状态文件位置
private boolean isHeadsetExists(){       //判断耳机是否插入的函数    FM源码 FMplayService.java  
        char[] buffer = new char[1024];
        int newState = 0;
        try {
            FileReader file = new FileReader(HEADSET_STATE_PATH);
            int len = file.read(buffer, 0, 1024);
            newState = Integer.valueOf((new String(buffer, 0, len)).trim());
        } catch (FileNotFoundException e) {
            Log.e(LOGTAG, "This kernel does not have wired headset support");
        } catch (Exception e) {
            Log.e(LOGTAG, "" , e);
        }
        return newState != 0;
   }
未插入耳机：
# cat /sys/class/switch/h2w/state
cat /sys/class/switch/h2w/state
0
插入耳机：
# cat /sys/class/switch/h2w/state
cat /sys/class/switch/h2w/state
1
sd卡和sim卡状态判断
//sdcard是否可读写 
public boolean IsCanUseSdCard() { 
    try { 
        return Environment.getExternalStorageState().equals( 
                Environment.MEDIA_MOUNTED); 
    } catch (Exception e) { 
        e.printStackTrace(); 
    } 
    return false; 
} 
//sim卡是否可读 
public boolean isCanUseSim() { 
    try { 
        TelephonyManager mgr = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); 
         return TelephonyManager.SIM_STATE_READY == mgr.getSimState(); 
    } catch (Exception e) { 
        e.printStackTrace(); 
    } 
    return false; 
} 
开机启动，检查sim卡是否发生变更
（1）注册receiver，设置意图过滤器
<receiver android:name=".receiver.BootCompleteReceiver" >
    <intent-filter android:priority="1000" >
        <action android:name="android.intent.action.BOOT_COMPLETED" />
    </intent-filter>
</receiver>
（2）接受开机广播，并判断sim卡时候发生更改
public class BootCompleteReceiver extends BroadcastReceiver {
    private static final String TAG = "BootCompleteReceiver";
    private SharedPreferences sp;
    private TelephonyManager tm;
    @Override
    public void onReceive(Context context, Intent intent) {
        Log.i(TAG,"手机重启了");
        sp = context.getSharedPreferences("config", Context.MODE_PRIVATE);
        boolean protecting = sp.getBoolean("protecting", false);
        //如果防盗保护开启
        if(protecting){
                //判断sim卡是否发生了变化
        tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
            String currentSim = tm.getSimSerialNumber();
            String savedSim= sp.getString("sim", "");
            if(savedSim.equals(currentSim)){
                    // sim卡为发生变化， do nothint
            }else{
                //sim卡发生了变化
                //发送报警短信 给安全号码
                SmsManager smsManager = SmsManager.getDefault();
                String destinationAddretss = sp.getString("safenumber", "");
                smsManager.sendTextMessage(destinationAddretss, null, "sim change !!!", null, null);
            }
        }
    }
}
判断SIM卡属于哪个移动运营商
第一种方法:
获取手机的IMSI码,并判断是中国移动\中国联通\中国电信  
TelephonyManager telManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); 
/** 获取SIM卡的IMSI码
* SIM卡唯一标识：IMSI 国际移动用户识别码（IMSI：International Mobile Subscriber Identification Number）是区别移动用户的标志，
* 储存在SIM卡中，可用于区别移动用户的有效信息。IMSI由MCC、MNC、MSIN组成，其中MCC为移动国家号码，由3位数字组成，
* 唯一地识别移动客户所属的国家，我国为460；MNC为网络id，由2位数字组成，
* 用于识别移动客户所归属的移动网络，中国移动为00，中国联通为01,中国电信为03；MSIN为移动客户识别码，采用等长11位数字构成。
* 唯一地识别国内GSM移动通信网中移动客户。所以要区分是移动还是联通，只需取得SIM卡中的MNC字段即可  
*/ 
String imsi = telManager.getSubscriberId();
if(imsi!=null){  
if(imsi.startsWith("46000") || imsi.startsWith("46002")){
//因为移动网络编号46000下的IMSI已经用完，所以虚拟了一个46002编号，134/159号段使用了此编号  
//中国移动  
}else if(imsi.startsWith("46001")){  
//中国联通  
}else if(imsi.startsWith("46003")){ 
//中国电信 
}  
}
第二种方法
TelephonyManager telManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); 
String operator = telManager.getSimOperator();
if(operator!=null){  
if(operator.equals("46000") || operator.equals("46002")){  
//中国移动  
}else if(operator.equals("46001")){  
//中国联通  
}else if(operator.equals("46003")){  
//中国电信 
}  
}  
在文件 AndroidManifest.xml中添加权限 
<uses-permission  android:name="android.permission.READ_PHONE_STATE"/> 
取得sim卡的网络类型
  public String getNetworkTypeName() {
        switch (getNetworkType()) {
            case NETWORK_TYPE_GPRS:
                return "GPRS";
            case NETWORK_TYPE_EDGE:
                return "EDGE";
            case NETWORK_TYPE_UMTS:
                return "UMTS";
            case NETWORK_TYPE_HSDPA:
                return "HSDPA";
            case NETWORK_TYPE_HSUPA:
                return "HSUPA";
            case NETWORK_TYPE_HSPA:
                return "HSPA";
            case NETWORK_TYPE_CDMA:
                return "CDMA";
            case NETWORK_TYPE_EVDO_0:
                return "CDMA - EvDo rev. 0";
            case NETWORK_TYPE_EVDO_A:
                return "CDMA - EvDo rev. A";
            case NETWORK_TYPE_EVDO_B:
                return "CDMA - EvDo rev. B";
            case NETWORK_TYPE_1xRTT:
                return "CDMA - 1xRTT";
            default:
                return "UNKNOWN";
        }
    }
手机卡种类：
private String getSimType() {
        // 获得SIMType 　　
        String simType = "";
        // 获得系统服务，从而取得sim数据 　　
        TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); 
        int type = tm.getNetworkType();
        System.out.println(Contants.DEBUG+" NetWorkType:"+type);
        //Test1:联通USIM卡，在这儿取出来的值为10-------NETWORK_TYPE_HSPA
        //Test2:中国移动 神州行OTA 2-----NETWORK_TYPE_EDGE
        //Test3:中国移动 动感地带OTA 2-----NETWORK_TYPE_EDGE
        //...
 
        switch (type) {
            case TelephonyManager.NETWORK_TYPE_UNKNOWN://0
                simType= "UNKOWN";
                break;
            case TelephonyManager.NETWORK_TYPE_GPRS://1
                simType= "SIM";
                break;
            case TelephonyManager.NETWORK_TYPE_EDGE://2
                simType= "SIM";
                break;
            case TelephonyManager.NETWORK_TYPE_UMTS://3
                simType= "USIM";
                break;
            case TelephonyManager.NETWORK_TYPE_CDMA://4
                simType= "Either IS95A or IS95B Card";
                break;
            case TelephonyManager.NETWORK_TYPE_EVDO_0://5
                simType= "EVDO revision 0 Card";
                break;
            case TelephonyManager.NETWORK_TYPE_EVDO_A://6
                simType= "EVDO revision A Card";
                break;
            case TelephonyManager.NETWORK_TYPE_1xRTT://7
                simType= "1xRTT Card";
                break;
            case TelephonyManager.NETWORK_TYPE_HSDPA://8
                simType= "HSDPA Card";
                break;
            case TelephonyManager.NETWORK_TYPE_HSUPA://9
                simType= "HSUPA Card";
                break;
            case TelephonyManager.NETWORK_TYPE_HSPA://10
                simType= "USIM";
                break;
             
        }
        System.out.println(Contants.DEBUG+" sim type :"+simType);
        return simType;
    }
各种手机卡知识：http://bbs.csdn.net/topics/390199890
单态模式实例
一：public class Singleton {
　　private Singleton(){}　　//注意这是private 只供内部调用
　　private static Singleton instance = new Singleton();　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　} 
}
二：public class Singleton {
　　private static Singleton instance = null;
　　public static synchronized Singleton getInstance() {//注意一定要加上关键字 synchronized  否则有可能得到多个Singleton实例
　　if (instance==null){
　　　　instance＝new Singleton();
}
　　return instance;
　　}
}
修改 特殊字符的命令（工程命令，如展讯*#*#83789#*#*）
TwelveKeyDialer.java afterTextChanged->
SpecialCharSequenceMgr.java ->handleChars ->handleSecretCode
/**
     * Handles secret codes to launch arbitrary activities in the form of *#*#<code>#*#*.
     * If a secret code is encountered an Intent is started with the android_secret_code://<code>
     * URI.
     *
     * @param context the context to use
     * @param input the text to check for a secret code in
     * @return true if a secret code was encountered
     */
    static boolean handleSecretCode(Context context, String input) {
        // Secret codes are in the form *#*#<code>#*#*
        int len = input.length();
        if (len > 8 && input.startsWith("*#*#") && input.endsWith("#*#*")) {
            Intent intent = new Intent(Intents.SECRET_CODE_ACTION,
                    Uri.parse("android_secret_code://" + input.substring(4, len - 4)));
            context.sendBroadcast(intent);
            return true;
        }
        return false;
    }
makefile详解
http://blog.csdn.net/zirconsdu/article/details/8005415
默认字体大小
frameworks/base/core/java/android/content/res/Configuration.java里面，有个fontScale=1
screen 默认拉伸大小  
settings->screen->Screen Scale
默认大小： DEFALUT_SCREEN_SCALE      手机存放路径： /sys/class/graphics/fb0/scale 或 /sys/class/graphics/fb2/scale
ScreenScaleManager.cpp
#define MAIN_DISPLAY_SCALE_FILE "/sys/class/graphics/fb0/scale"
#define AUX_DISPLAY_SCALE_FILE "/sys/class/graphics/fb2/scale"
获得圆角图片的方法
public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, float roundPx) {

Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Config.ARGB_8888);
Canvas canvas = new Canvas(output);

final int color = 0xff424242;
final Paint paint = new Paint();
final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
final RectF rectF = new RectF(rect);

paint.setAntiAlias(true);
canvas.drawARGB(0, 0, 0, 0);
paint.setColor(color);
canvas.drawRoundRect(rectF, roundPx, roundPx, paint);

paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
canvas.drawBitmap(bitmap, rect, rect, paint);

return output;
}

网络下载
private Runnable mdownApkRunnable = new Runnable() {      
        @Override  
        public void run() {  
            try {  
                URL url = new URL(apkUrl);  
              
                HttpURLConnection conn = (HttpURLConnection)url.openConnection();  
                conn.connect();  
                int length = conn.getContentLength();  
                InputStream is = conn.getInputStream();  
                  
                File file = new File(savePath);  
                if(!file.exists()){  
                    file.mkdir();  
                }  
                String apkFile = saveFileName;  
                File ApkFile = new File(apkFile);  
                FileOutputStream fos = new FileOutputStream(ApkFile);  
                  
                int count = 0;  
                byte buf[] = new byte[1024];  
                  
                do{                   
                    int numread = is.read(buf);  
                    count += numread;  
                    progress =(int)(((float)count / length) * 100);  
                    //更新进度  
                    mHandler.sendEmptyMessage(DOWN_UPDATE);  
                    if(numread <= 0){      
                        //下载完成通知<span style="BACKGROUND-COLOR: #ffd700">安装</span>  
                        mHandler.sendEmptyMessage(DOWN_OVER);  
                        break;  
                    }  
                    fos.write(buf,0,numread);  
                }while(!interceptFlag);//点击取消就停止下载.  
                  
                fos.close();  
                is.close();  
            } catch (MalformedURLException e) {  
                e.printStackTrace();  
            } catch(IOException e){  
                e.printStackTrace();  
            }  
              
        }  
    };  
      
     /** 
     * 下载apk 
     * @param url 
     */  
      
    private void downloadApk(){  
        downLoadThread = new Thread(mdownApkRunnable);  
        downLoadThread.start();  
    }  
一个弹出AlertDialog实例、机器重启（reboot）实例
new AlertDialog.Builder(EthernetStaticIP.this)
<span style="WHITE-SPACE: pre">	</span>.setTitle(R.string.str_about)
<span style="WHITE-SPACE: pre">	</span>.setMessage(R.string.str_reboot)
<span style="WHITE-SPACE: pre">	</span>.setPositiveButton(R.string.str_ok, 
<span style="WHITE-SPACE: pre">		</span> new DialogInterface.OnClickListener()
<span style="WHITE-SPACE: pre">		</span> {
<span style="WHITE-SPACE: pre">		</span>    public void onClick(DialogInterface dialoginterfacd,int i)
<span style="WHITE-SPACE: pre">		</span>    {
<span style="WHITE-SPACE: pre">		</span>    <span style="WHITE-SPACE: pre">	</span>//reboot
<span style="WHITE-SPACE: pre">		</span>    /*final static */String SYSTEMUI_REBOOT_ACTION = "com.android.systemui.reboot";
                Intent intent = new Intent();
                intent.setAction(SYSTEMUI_REBOOT_ACTION);
                EthernetStaticIP.this.sendBroadcast(intent);
<span style="WHITE-SPACE: pre">		</span>    }
<span style="WHITE-SPACE: pre">		</span> } 
<span style="WHITE-SPACE: pre">	</span>)
<span style="WHITE-SPACE: pre">	</span>.setNegativeButton(R.string.str_cancel,
<span style="WHITE-SPACE: pre">		</span> new DialogInterface.OnClickListener()
<span style="WHITE-SPACE: pre">	</span> {
<span style="WHITE-SPACE: pre">			</span>public void onClick(DialogInterface dialoginterfacd,int i)
<span style="WHITE-SPACE: pre">			</span>{
<span style="WHITE-SPACE: pre">				</span>finish();
<span style="WHITE-SPACE: pre">			</span>}
<span style="WHITE-SPACE: pre">	</span> }  <span style="WHITE-SPACE: pre">		</span>
<span style="WHITE-SPACE: pre">	</span>)
<span style="WHITE-SPACE: pre">	</span>.show();
reboot代码：
frameworks\base\services\java\com\android\server\wm\WindowManagerService.java   增加代码 
    final static String SYSTEMUI_POWEROFF_ACTION = "com.android.systemui.poweroff";
    final static String SYSTEMUI_REBOOT_ACTION = "com.android.systemui.reboot";
    final BroadcastReceiver mAdditionalReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if(SYSTEMUI_POWEROFF_ACTION.equals(intent.getAction())){
                Log.d(TAG,"wms calling shutdown dlg from broadcast..");
                shutdown();//ShutdownThread.shutdown(context,true);
            }else if(SYSTEMUI_REBOOT_ACTION.equals(intent.getAction())){	
                Log.d(TAG,"wms calling shutdown dlg from broadcast..");
                reboot();
            }
        }
    };
    public void shutdown() {
        ShutdownThread.shutdown(mContext, true);
    }	
    public void reboot() {
        ShutdownThread.reboot(mContext, null, false);
    }
及注册广播接收
        IntentFilter f = new IntentFilter();
        f.addAction(SYSTEMUI_POWEROFF_ACTION);
        f.addAction(SYSTEMUI_REBOOT_ACTION);	
        mContext.registerReceiver(mAdditionalReceiver, f);
获得内存信息，cpu信息、频率等
通过读取文件/proc/cpuinfo系统CPU的类型等多种信息。
读取/proc/stat 所有CPU活动的信息来计算CPU使用率 ，   "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq" 存储最大频率的文件的路径， cpuinfo_min_freq最低频率，scaling_cur_freq当前频率
通过读取文件/proc/meminfo的信息获取Memory的总量。
ActivityManager. getMemoryInfo(ActivityManager.MemoryInfo)获取当前的可用Memory量
LOCAL_REQUIRED_MODULES
mms Android.mk 中 含有：LOCAL_REQUIRED_MODULES := SoundRecorder
LOCAL_REQUIRED_MODULES的作用当编译整个android源码时，如果mms模块在编译路径中（即可以编译打包到system.img下），
则会自动编译SoundRecorder，并且打包到system.img，如果不是编译整个源码，只是mm。则不会编译SoundRecorderl生成相应的apk文件。
<xliff:g>标签介绍
定义可变的字符串： 
当一个字符串中只包含一个可变的数 
例如这样： <string name="tedst"> %d首歌曲。</string>这样正确的 
当一个字符串中只包含多个可变的数  
例如： <string name="tedst">%d张专辑 %d首歌曲。</string>，这样是错误的 
当你字符串中包含多个 %d，需要用xliff:g来格式化字符串
<string name="appwidget_text_format"><xliff:g id="prefix">%1$s</xliff:g>: <xliff:g id="time">%2$s</xliff:g></string>
这个主要用于程序中，动态的插入内容时候使用，例如，
<string name="time">当前时间：<xliff:g id="prefix">%1$s</xliff:g>时 <xliff:g id="time">%2$s</xliff:g>分</string>
然后通过程序，context.getString(R.string.time,"10","05");
将会输出——当前时间：10时05分 
属性id可以随便命名 
属性example表示举例说明，可以省略 
%n$ms：代表输出的是字符串，n代表是第几个参数，设置m的值可以在输出之前放置空格 
%n$md：代表输出的是整数，n代表是第几个参数，设置m的值可以在输出之前放置空格，也可以设为0m,在输出之前放置m个0 
%n$mf：代表输出的是浮点数，n代表是第几个参数，设置m的值可以控制小数位数，如m=2.2时，输出格式为00.00 
注意：一定要增加命名空间 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">  否则会编译不过Error parsing XML: unbound prefix 
android kernel log图片 生成工具 
log_make.sh   logo_linux_clut224.ppm
#!/bin/sh 

echo "make logo_linux_clut224.ppm start"
cd ./1/
echo "--make linuxlogo.pnm"
pngtopnm ../linuxlogo.png > linuxlogo.pnm
echo "--make linuxlogo224.pnm"
pnmquant 224 linuxlogo.pnm > linuxlogo224.pnm 
echo "--make logo_linux_clut224.pnm"
pnmtoplainpnm linuxlogo224.pnm > logo_linux_clut224.ppm

cd ..
echo "make logo_linux_clut224.ppm end"

android定位代码
定位出现问题的代码：
12-26 14:29:47.801 I/DEBUG ( 100): backtrace:
12-26 14:29:47.801 I/DEBUG ( 100): #00 pc 00016ce0 /system/lib/libc.so (strcmp+32)
12-26 14:29:47.801 I/DEBUG ( 100): #01 pc 000035bb /system/bin/vold
12-26 14:29:47.801 I/DEBUG ( 100): #02 pc 00003521 /system/bin/vold
12-26 14:29:47.801 I/DEBUG ( 100): #03 pc 00002b57 /system/lib/libsysutils.so (NetlinkListener::onDataAvailable(SocketClient*)+166)
12-26 14:29:47.801 I/DEBUG ( 100): #04 pc 000025cf /system/lib/libsysutils.so (SocketListener::runListener()+490)
在工程的根目录下的shell端输入：addr2line -e out/target/product/rk31sdk/symbols/system/bin/vold 00003521
其中，00003521为出现问题的pc指针 
结果为：system/vold/MiscManager.cpp:85
addr2line -e out/target/product/rk31sdk/symbols/system/bin/vold 000035bb 
system/vold/G3Dev.cpp:63
android ril的加载
在init.rc文件中进行加载Android RIL模块
service ril-daemon /system/bin/rild -l /system/lib/libreference-ril.so -- -d /dev/ttyS0
也可以手动加载：
/system/bin/rild -l /system/lib/libreference-ril.so -- -d /dev/ttyS0
这两种方式，都将启动rild守护进程，然后通过-l参数将libreference-ril.so共享库链入，libreference-ril.so的参数-d是指加载一个串口设备，/dev/ttyS0则是这个串口设备的具体设备文件，除了参数-d外，还有-s代表加载类型为socket的设备，-p代表回环接口
监控电话状态： 来电、通话中、空闲
获取电话服务： 在启动Activity时间获取电话服务
	TelephonyManager telephonyManager = (TelephonyManager) this.getSystemService(Context.TELEPHONY_SERVICE);
        MyPhoneStateListener myPhoneStateListener = new MyPhoneStateListener();
        // 手动注册对PhoneStateListener中的listen_call_state状态进行监听通話
        telephonyManager.listen(myPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
MyPhoneStateListener类
/**
 * 继承PhoneStateListener类，我们可以重新其内部的各种监听方法
 * 然后通过手机状态改变时，系统自动触发这些方法来实现我们想要的功能
 */
public class MyPhoneStateListener extends PhoneStateListener {
    /**
     * @param state 通話狀態
     * @param incomingNumber   手機號碼
     */
    @Override
    public void onCallStateChanged(int state, String incomingNumber) {
        switch (state) {
            case TelephonyManager.CALL_STATE_IDLE:
                Log.e("---------", "挂掉");
                break;
            case TelephonyManager.CALL_STATE_RINGING:
                Log.e("---------", "有来电，号码是：" + incomingNumber);
                break;
            case TelephonyManager.CALL_STATE_OFFHOOK:
                Log.e("---------", "通話中");
            default:
                break;
        }
        super.onCallStateChanged(state, incomingNumber);
    }
}
相关权限
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
NetworkOnMainThreadException错误解决：在主线程中访问了网络数据
E/AndroidRuntime(1562): android.os.NetworkOnMainThreadException
E/AndroidRuntime(1562): at android.os.StrictMode$AndroidBlockGuardPolicy.onNetwork(StrictMode.java:1118)
查看Ubuntu版本、位数
1.cat /etc/issue
2.cat /etc/lsb-release 
3.uname -a
位数：getconf LONG_BIT
 java工具 javah和javap的使用（获取、生成java native函数signature工具）
javah的使用： 生成jni C函数声明  在工程目录\bin\classes目录下执行 javah -o 生成的头文件.h -jni java包名.类名 
     例：javah -o android_hardware_miscdevice.h -jni com.odm.misc.MiscDevice
javap的使用：获得java文件的native函数签名    在工程目录\bin\classes目录下执行 javap -s packagename.classname
            例： D:\workspace\TtyTester\bin\classes>javap -s com.odm.tty.ttyutil
Compiled from "TtyUtil.java"
public class com.odm.tty.TtyUtil extends java.lang.Object{
public static final java.lang.String A4_RFID_RDM_TTY_DEV;
。。。
  Signature: Ljava/lang/String;
public static final java.lang.String UE966_TTY_DEV;
  Signature: Ljava/lang/String;
public com.odm.tty.TtyUtil();
  Signature: ()V
}
ubuntu samba可视化共享
sudo apt-get install samba
sudo apt-get install smbfs
sudo apt-get install system-config-samba
sudo /etc/init.d/samba start
sudo system-config-samba 
远程桌面登陆ubuntu后无法使用键盘输入小写s和m
在xp上所有程序->附件->远程桌面连接  连接上Ubuntu后，发现输入字母s或m后，分别弹出logout菜单和message菜单
百度搜索结果中列出了文章的部分信息，一个关键的url：https://bugs.launchpad.net/ubuntu/+source/indicator-applet/+bug/568401
 打开后，发现原来是indicator applet引起的bug具体修复步骤如下：
1.sudo apt-get install apt-show-versions  (安装用于查看Ubuntu软件包版本的应用)
2.sudo apt-show-versions | grep indicator-applet (查看安装的indicator applet版本)发现安装的版本正是0.3.6，存在bug的那个版本
3.sudo apt-get install indicator-applet   (更新至最新版本 0.3.7)
4.重启机器后ok
使用adb 调试串口
Android手机上很多外设是串口连接到AP的，如modem，gps。为了调试这些串口，通常需要将它们飞线接出来，用pc的串口连接调试。这样比较麻烦。
在adb  shell里是可以直接调试串口的，就不用飞线了，还可以验证Android串口配置是否正确。
用usb连接Android设备调试后，在pc端输入 adb shell，连接成功后，先停止一些可能占用端口的服务，如：
stop ril-daemon停掉ril后台
然后：
busybox microcom -t 15000 -s 115200 /dev/ttyS0
-t 单位毫秒，无操作自动退出时间。
-s 单位bps，串口波特率。
ttyS0 要操作的串口。
然后打开另一个命令行窗口，输入：
adb shell cat /dev/ttyS0
然后可以在第一个窗口输入命令，在第二个窗口可以看到命令和响应。
如果没有响应，请检查Android串口配置是否正确，串口号是否对，波特率是否正确。
microcom的-t设置要合理，太短，输入命令可能输入不完就退出了，太长要等很久才退出。
必须先执行第一个窗口，再执行第二个窗口，因为不设置波特率，第二个窗口显示会有问题。
第一个窗口microcom退出后，也可以用以下方法发送命令到串口：
echo -e "AT\r\n">/dev/ttyS0
启动另外一个进程中的acitivity
Intent i = new Intent();
ComponentName cpName = new ComponentName("lee.magniwill.testserial", "lee.magniwill.testserial.MainActivity");
i.setComponent(cpName);
i.setAction("android.intent.action.MAIN");
启动同一个进程中的acitivity
Intent intent = new Intent("lee.magniwill.testserial.MainActivity");
startActivity(intent);
通过字符串来使用R下面资源的ID 值 
方法一：      
Resources resources=getResources(); 
String resStr = "weather_"+iconToday[0];
int resID = resources.getIdentifier(resStr, "drawable", getPackageName());
log("image to show: "+resStr + " id="+resID);
log结果：04-13 12:17:46.509: D/WeatherForecast(2173): --- image to show: weather_7 id=2130837534 ---
方法二
try{ 
	Field field=R.drawable.class.getField(resStr); 
	int <span style="font-family: Arial, Helvetica, sans-serif;">resID </span>= field.getInt(new R.drawable()); 
	log("image to show: "+resStr + " id="+resID);
}catch(Exception e){ 
	log(resStr,e.toString()); 
}

拦截HOME键、power键
修改文件：frameworks\base\policy\src\com\android\internal\policy\impl\PhoneWindowManager.java 
函数 interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags) {
...
if (keyCode == KeyEvent.KEYCODE_HOME) {
mContext.sendBroadcast(intetn);发送一个broatcast广播， 然后在需要拦截home键的apk中接收改广播并做相应处理即可
}
...
}
power键
    public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn) {
       case KeyEvent.KEYCODE_POWER: {
                result &= ~ACTION_PASS_TO_USER;

// add begin app端可以接收 KEYCODE_POWER消息
ActivityManager activityManager = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
try{
String calssName = activityManager.getRunningTasks(1).get(0).topActivity.getClassName();//得到当前的activity名称
if ("com.xhw.fuctions.TakePicActivity".equals(calssName)){
//Please reset the special package name.
result |= ACTION_PASS_TO_USER;
Log.d(TAG,"detect power key in special package, pass to user!");
break;
}
}catch(NullPointerException e){
Log.d(TAG,"ingore a NullPointerException ..");
}
//add end
}
禁止系统安装其他任何apk
修改文件： /frameworks/base/cmds/pm/src/com/android/commands/pm/Pm.java
注释掉 runInstall();的调用处即可
C语言文件的读写、java语言文件的读写
	FILE*  fp =    fopen("/storage/sdcard1/medias/config.txt","rt");
	// int fread(void *ptr, int size, int nitems, FILE *stream);
	//返回值 int 代表真的读取了多少次  size的长度
	//*ptr  数据读到哪个内存空间里面
	// size 一次读取的数据的长度是多个字节
	// nitmes读取多少次数据
	// stream 从哪个文件里面读
	int read = fread(mPoliceCode, sizeof(char)*6, 1, fp);
	ALOGE("!!!    !!! mPoliceCode  read =%d", read); 
	char recordLen[2] = {0};

	//int fseek(FILE *stream, long offset, int fromwhere);
	fseek(fp, 6 +1, SEEK_SET);	//警号是6位，加1位换行符
	read = fread(recordLen, sizeof(char)*1, 1, fp);
	ALOGE("!!!   !!! recordLen  read =%d", read); 
	mRecordlength = atoi(recordLen);
	ALOGE("!!!    mPoliceCode: %s, recordLen: %s, mRecordlength: %d　read=", mPoliceCode, recordLen, mRecordlength, read); 
	
	fclose(fp);//关闭流
private void saveConfigs() {
		String configFileNameString = "config.txt";
		
		File settingsFile = new File(FileUtil.getDefStoragePath() + File.separator + "medias"+File.separator+ configFileNameString);
		// 如果文件不存在则创建之
		log("saveConfigs  = "+settingsFile.getAbsolutePath());
		if (!settingsFile.exists()) {
			try {
				boolean ret = settingsFile.createNewFile();
				log("saveConfigs  "+settingsFile.getAbsolutePath()+" isn't exist! create it success?=" + ret);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log("saveConfigs create "+settingsFile.getAbsolutePath()+" error! " + e.getMessage());
			}
		}
		
		OutputStreamWriter osw = null;
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream(settingsFile);
			osw = new OutputStreamWriter(fos, "gb2312");
			
			//写入警号
			osw.write(MyApplication.policeCodeString);
			osw.write("\n");
			//写入分段时间
			osw.write(MyApplication.recordlength+"");
			log("saveConfigs  code ="+MyApplication.policeCodeString +" recordlength=" + MyApplication.recordlength);
			
			osw.flush();
			osw.close();
			fos.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			try {
				if(osw != null) osw.close();
				if(fos != null) fos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
	}
如何对手机内存中的文件数据进行读写呢？
    Context提供了领个方法来打开该应用程序的数据文件夹中的文件I/O流，具体如下：
    FileInputStream openFileInput(String name)打开应用程序的数据文件夹下的name文件对应的数据流
    FileOutputSream openFileOutput(String name, int mode)打开应用程序数据文件夹下的name文件对应的输出流，mode指定文件打开的模式，该模式主要有一下4种：
    ①MODE_PRIVATE(该文件只能被当前应用程序读写)
    ②MODE_APPEND(以追加方式打开，可以在文件中追加内容)
    ③MODE_WORLD_READABLE(该文件内容可以被其他应用程序读取)
    ④MODE_WORLD_WRITEABLE(该文件内容可以被其他应用程序度，写)
    读取文件：
    假设name为要打开的文件名字
    FileInputStream f = openFileInput(name);
    byte[] buf = new byte[1024];
    int hasRead = 0;
    StringBuilder sb = new StringBuilder("");
    while((hasRead = f.read(buf)>0))
    {
      sb.append(new String(buf, 0 , hasRead));
     }
    f.close();
    获取文件内容字符串：sb.toString();
    写文件：
    假设要写入的字符串为content
    FileOutputStream f = openFileOutput(name, MODE_APPEND);
    PrintStream temp = new PrintStream(f);
    temp.println(content);
    temp.close();
注：应用程序的数据文件默认保存在/data/datea<package name>/files目录下，使用openFileInput和openFileOutput方法来打开文件输入流，输出流时，打开的都是应用程序的数据文件夹里的文件，也就是说是在手机内存中的文件，而不是SD卡中的文件。
eclipse导入andriod源码jar包路径：
现在我需要导入Setting源码到eclipse ，导入之后会有很多地方报错，未能找到相关类，需要我们导入相应jar包，现在我们如何知道需要导入哪些jar包？
路径：out/target/common/obj/JAVA_LIBRARIES/framework_intermediates/下编译的classes.jar
android:protectionLevel 的修改  例如修改串口权限
一些需要system级别的权限，例如android.permission.SERIAL_PORT  apk必须需要android:sharedUserId="android.uid.system"  的signature才可以安装，不然会报错：  INSTALL_FAILED_SHARED_USER_INCOMPATIBLE，   此时可以修改文件 frameworks/base/core/res/AndroidManifest.xml  把     -        android:protectionLevel="signature|system" /> 修改为   +        android:protectionLevel="normal" />   然后其他需要SERIAL_PORT权限的apk 就可以直接安装了
通过包名获取其他包的Context实例
Context有个createPackageContext方法，可以创建另外一个包的上下文，这个实例不同于它本身的Context实例，但是功能是一样的。这个方法有两个参数：
1。packageName  包名，要得到Context的包名
2。flags  标志位，有CONTEXT_INCLUDE_CODE和CONTEXT_IGNORE_SECURITY两个选项。CONTEXT_INCLUDE_CODE的意思是包括代码，也就是说可以执行这个包里面的代码。CONTEXT_IGNORE_SECURITY的意思是忽略安全警告，如果不加这个标志的话，有些功能是用不了的，会出现安全警告。
判断是否是在漫游
    private boolean isRoaming() {
        Boolean isRoaming = false;
	  if(mContext == null) return isRoaming;
		
        ConnectivityManager connectivityManager = (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
        isRoaming = (networkInfo != null
                && networkInfo.getType() == ConnectivityManager.TYPE_MOBILE 
                && networkInfo.isRoaming());
        Log.d(TAG, "jimbo---KeyguardStatusView isRoaming " + isRoaming);
        return isRoaming;
    }
android:layout_weight使用
只有在Linearlayout中，该属性才有效。之所以Android:layout_weight会引起争议，是因为在设置该属性的同时，设置android:layout_width为wrap_content和match_parent会造成两种截然相反的效果
android:layout_weight的真实含义是:一旦View设置了该属性(假设有效的情况下)，那么该 View的宽度等于原有宽度(android:layout_width)加上剩余空间的占比！
设屏幕宽度为L，在两个view的宽度都为match_parent的情况下，原有宽度为L，两个的View的宽度都为L，那么剩余宽度为L-（L+L） = -L, 左边的View占比三分之一，所以总宽度是L+(-L)*1/3 = (2/3)L.事实上默认的View的weight这个值为0，一旦设置了这个值，那么所在view在绘制的时候执行onMeasure两次的原因就在这。
Google官方推荐，当使用weight属性时，将width设为0dip即可，效果跟设成wrap_content是一样的。这样weight就可以理解为占比了！
最合理的使用方式：当使用weight属性时，将width设为0dip
Android 获取控件的宽和高/ 如何获取控件的大小
在onCreate()里面获取控件的高度是0,

//------------------------------------------------方法一   自己测量 
int w = View.MeasureSpec.makeMeasureSpec(0,View.MeasureSpec.UNSPECIFIED);  
int h = View.MeasureSpec.makeMeasureSpec(0,View.MeasureSpec.UNSPECIFIED);  
imageView.measure(w, h);  
int height =imageView.getMeasuredHeight();  
int width =imageView.getMeasuredWidth();  
textView.append("\n"+height+","+width);  
  
  
  
  
<div style="text-indent: 28px;"><span style="font-family: Arial, Helvetica, sans-serif;">//-----------------------------------------------方法二 </span><span style="font-family:宋体;color:#333333;"><span style="font-size: 14px; line-height: 28px; background-color: rgb(249, 249, 249);">  注册一个ViewTreeObserver的监听回调，这个监听回调，就是专门监听绘图的，既然是监听绘图，那么我们自然可以获取测量值了，同时，我们在每次监听前remove前一次的监听，避免重复监听。 </span></span></div>ViewTreeObserver vto = imageView.getViewTreeObserver();  
vto.addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {  
    public boolean onPreDraw() {  

<code class="java plain" style="line-height: 15.3999996185303px; font-size: 14px; white-space: pre; border-top-left-radius: 0px !important; border-top-right-radius: 0px !important; border-bottom-right-radius: 0px !important; border-bottom-left-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: inherit !important; background: none !important;"><span style="white-space:pre">	</span>vto.removeOnPreDrawListener(</code><code class="java keyword" style="line-height: 15.3999996185303px; font-size: 14px; white-space: pre; border-top-left-radius: 0px !important; border-top-right-radius: 0px !important; border-bottom-right-radius: 0px !important; border-bottom-left-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: inherit !important; color: rgb(0, 102, 153) !important; background: none !important;">this</code><code class="java plain" style="line-height: 15.3999996185303px; font-size: 14px; white-space: pre; border-top-left-radius: 0px !important; border-top-right-radius: 0px !important; border-bottom-right-radius: 0px !important; border-bottom-left-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: inherit !important; background: none !important;">);</code>
        int height = imageView.getMeasuredHeight();  
        int width = imageView.getMeasuredWidth();  
        textView.append("\n"+height+","+width);  
        return true;  
    }  
});  
//-----------------------------------------------方法三       <span style="color: rgb(51, 51, 51); font-family: 宋体; font-size: 14px; line-height: 28px; background-color: rgb(249, 249, 249);">第2个方法基本相同，但他是全局的布局改变监听器，所以是最推荐使用的</span>
ViewTreeObserver vto2 = imageView.getViewTreeObserver();    
vto2.addOnGlobalLayoutListener(new OnGlobalLayoutListener() {  
    @Override    
    public void onGlobalLayout() {  
        imageView.getViewTreeObserver().removeGlobalOnLayoutListener(this);    
        textView.append("\n\n"+imageView.getHeight()+","+imageView.getWidth());  
    }    
});