Android Formatting strings declare

declare string format

<string name="msg">Hello, %1$s! You have %2$d messages.</string>

%[position]$[type]

Using in code:

String.format(getResource().getString(R.string.msg), name, count);

Android dp and px換算

換算公式 target px = mdpi px * ( target dpi / 160 )
為了符合原本長度
dpi高的時候要比低dpi時用更多px表示 Android API: 直接從res/dimen換成px

int px = (int) getResources().getDimension(R.dimen.XXX)

數字轉換

TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 20, r.getDisplayMetrics())

讀取project下的檔案，getResourceAsStream() 用法

在android 開發的時候常常會需要讀取project 下的檔案，這時候就要用class loader來讀取.

有下面這兩種用法

    ClassLoader.getResourceAsStream("filepath")  

    Class.getResourceAsStream("filepath")

 

差別在於，Class是從package下當根目錄開始找檔案, class  loader則是從class path開始找(也就是說project的根目錄也包含其中)

Java加解密Class使用 - 對稱加密

稍微記錄一下Java中加密類別的使用方法，要使用加解密會用到下列三個Class：KeyGenerator、SecretKey、Cipher。  KeyGenerator主要是負責產生加解密用的Key
例如

KeyGenerator keygen = KeyGenerator.getInstance("DES");//參數代表使用的加解密演算法
SecretKey key = keygen.generateKey(); //產生key

在產生完Key後，利用Cipher來對資料加密。

String str ="example";
byte[] src = str.getBytes();
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE, key);//決定是何種模式有  ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, UNWRAP_MODE
byte [] result = cipher.doFinal(src);//依據設定的Mode來開始動作，result即為加密後之密文

如果要解密的話，則改用DECRYPT_MODE

cipher.init(Cipher.ENCRYPT_MODE, key);
byte [] src = cipher.doFinal(result);//取回明文，在轉換回對應之type即可
String str = new String(src);

因為對稱加密，加解密都是用同一把Key所以會需要保存Key，最簡單的方法就是使用檔案來存放，例如

//存成檔案
byte [] bytekey = key.getEncoded();
int len = bytekey.length;
FileOutputStream fos;
fos = new FileOutputStream(FILEPATH)
fos.write(bytekey);
fos.close();
//讀檔
byte [] buf = new byte[len]
FileInputStream fis = new FileInputStream(FILEPATH); 
int i = fis.read(buf);
fis.close();

SecretKey resultKey = new SecretKeySpec(buf, "DES");//從byte array轉回key

當然也可用ObjectInputStream、ObjectOutputStream拉，如此一來就可以少去byte轉換的動作。

LocalBroadcastManager 使用

LocalBroadcastManager 簡單的說就是intra-app的Broadcast 發送，用來避免Broadcast  發送到外部所造成的security issue(當然你也可以指定target或是用Permission拉...)。 下面是Android 上所提到的優點：
   

• You know that the data you are broadcasting won't leave your app, so don't need to worry about leaking private data.
• It is not possible for other applications to send these broadcasts to your app, so you don't need to worry about having security holes they can exploit.
• It is more efficient than sending a global broadcast through the system. 

 簡單的說就是app內部的 Broadcast系統，不會發送到外部也不會被外部的Broadcast影響。唯一一個小小的缺點就是要自行import  Android Compatibility package， 要記得把 android-support-v4.jar 放到libs下即可。  可以看一下官方的文件LocalBroadcastManager  ，就幾個簡單的API而已。
範例

LocalBroadcastManager mLocalBroadcastManager;
public void onCreate(Bundle savedInstanceState) {
    mLocalBroadcastManager = LocalBroadcastManager.getInstance(getApplicationContext());   //要先getInstance
}

protected void onPause() {
    mLocalBroadcastManager.unregisterReceiver(TTLNotifyReceiver);
}

protected void onResume() {  
    IntentFilter filter = new IntentFilter("com.test.hello");
    mLocalBroadcastManager.registerReceiver(receiver, filter);
}

private BroadcastReceiver receiver = new BroadcastReceiver() {
    public void onReceive(Context context, Intent intent) {
 //rece the Intent
    }
};

Ant Import 和 Include的差異

http://ant.apache.org/manual/Tasks/include.html

其實官方網頁寫得很清楚了，貼一下原文

The short version: Use import if you intend to override a target, otherwise use include.
When using import the imported targets are available by up to two names. Their "normal" name without any prefix and potentially with a prefixed name (the value of the as attribute or the imported project's name attribute, if any).
When using include the included targets are only available in the prefixed form.
When using import, the imported target's depends attribute remains unchanged, i.e. it uses "normal" names and allows you to override targets in the dependency list.
When using include, the included targets cannot be overridden and their depends attributes are rewritten so that prefixed names are used. This allows writers of the included file to control which target is invoked as part of the dependencies.
It is possible to include the same file more than once by using different prefixes, it is not possible to import the same file more than once.

意思就是說如果被導入的target需要被 override的話就用import，不然用include即可。

例如官方的例子， 下面是要被導入的nested.xml

<project>
  <target name="setUp">
    <property name="prop" value="in nested.xml"/>
  </target>

  <target name="echo" depends="setUp">
    <echo>prop has the value ${prop}</echo>
  </target>
</project>

如果用import


<project default="test">
  <target name="setUp">
    <property name="prop" value="in importing"/>
  </target>

  <import file="nested.xml" as="nested"/>

  <target name="test" depends="nested.echo"/>
</project>


結果會是


setUp:

nested.echo:
     [echo] prop has the value in importing

test:
如果用include
<project default="test">
  <target name="setUp">
    <property name="prop" value="in importing"/>
  </target>

  <include file="nested.xml" as="nested"/>

  <target name="test" depends="nested.echo"/>
</project>


結果會變成

nested.setUp:

nested.echo:
     [echo] prop has the value in nested.xml

test:

結論: 如果沒有要改動到導入的XML東西用include即可，反之則用import

Java sleep(), yield()/join(), notify()/notifyAll()/wait() 用法差異

http://dylanxu.iteye.com/blog/1322066
太久沒有用到，最近要用到的時候又忘了...
乾脆把他整理一下。


1.sleep, yield, join 基本上都是Thread scheduling的method，sleep跟yield用法差不多，基本上就是Thread不需要執行的時候呼叫，只是差在sleep可以決定時間。

join則是等待某個Thread執行完，例如

                thread.join() //等thread跑完 在繼續

2.notify()/notifyAll()/wait() 則是Data Lock的部分，這些method都要在synchronized block中呼叫，不然會丟exception。

如果wait()的Thread要離開可以呼叫Thread的interrupt(); 會丟InterruptedException，可以跳離wait()狀態。

try {   
    while(true) {
        synchronized (this) {
            wait();
        }
    } 
} catch (InterruptedException e) {
    //interrupt triger
}