wpa_supplicant 連線 wpa-psk-ccmp 的ap

ps. 有些ap上面是寫AES而不是CCMP

ctrl_interface=/var/run/wpa_supplicant

network={

ssid="xxxxxx"

key_mgmt=WPA-PSK

proto=WPA

pairwise=CCMP

group=CCMP

psk="xxxxxxxxxx"

}

N1 泡水機拆解

螢幕進水

鏡頭進水＆金屬生鏽

生鏽...

燒焦？

主電路板

螢幕背面與電容試觸控

軌跡球

超薄的oled

android 螢幕旋轉演算法

eclair只支援兩種方向：rotation 0 and rotation 90

CyanogenMod有支援四個方向

最新的froyo應該是支援三個方向（等froyo release再把他的演算法po上來）

source code 在 framework/base/core/java/android/view/WindowOrientationListenetr.java這裡支援的方向指的是android送給上層依據目前g-sensor算出來的螢幕旋轉方向，

程式部份自己要去對旋轉的方向作處理，預設的setting程式就有支援四個方向，

ui(Launcher)部份，把AndroidManifest.xml的android:screenOrientation="nosensor"改成sensor就可以了

以下是詳細的演算法：

CyanogenMod 有支援四個方向，基本上是從原本eclair的演算法算出orientation之後的部份作修改：

android 繪圖程式範例

拿這個範例改的（修正原本要畫完放開滑鼠之後才會出現線段）

http://www.tutorialforandroid.com/2009/06/drawing-with-canvas-in-android.html

source code:

package com.cyl.android.draw;



import java.util.ArrayList;

import android.app.Activity;

import android.content.Context;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.graphics.Path;

import android.os.Bundle;

import android.view.MotionEvent;

import android.view.SurfaceHolder;

import android.view.SurfaceView;



public class draw extends Activity {

private ArrayList _graphics = new ArrayList();

private Paint mPaint;







@Override

 public void onCreate(Bundle savedInstanceState) {

     super.onCreate(savedInstanceState);

     setContentView(new DrawingPanel(this));

     mPaint = new Paint();

     mPaint.setDither(true);

     mPaint.setColor(0xFFFF0000);

     mPaint.setStyle(Paint.Style.STROKE);

     mPaint.setStrokeJoin(Paint.Join.ROUND);

     mPaint.setStrokeCap(Paint.Cap.ROUND);

     mPaint.setStrokeWidth(3);



}







class DrawingPanel extends SurfaceView implements SurfaceHolder.Callback {

private DrawingThread _thread;

private Path path;



public DrawingPanel(Context context) {

 super(context);

         getHolder().addCallback(this);

         _thread = new DrawingThread(getHolder(), this);

}



@Override

     public boolean onTouchEvent (MotionEvent event) {

         synchronized (_thread.getSurfaceHolder()) {

          if(event.getAction() == MotionEvent.ACTION_DOWN){

           path = new Path();

           path.moveTo(event.getX(), event.getY());

          }else if(event.getAction() == MotionEvent.ACTION_MOVE){

           path.lineTo(event.getX(), event.getY());

           _graphics.add(path);

           path = new Path();

           path.moveTo(event.getX(), event.getY());

          }else if(event.getAction() == MotionEvent.ACTION_UP){

           path.lineTo(event.getX(), event.getY());

           _graphics.add(path);

          }

        

          return true;

         }

}



@Override

     public void onDraw(Canvas canvas) {

 for (Path path : _graphics) {

  canvas.drawPath(path, mPaint);

 }

}







public void surfaceCreated(SurfaceHolder holder) {

 // TODO Auto-generated method stub

 _thread.setRunning(true);

         _thread.start();

}



public void surfaceDestroyed(SurfaceHolder holder) {

 // TODO Auto-generated method stub

 boolean retry = true;

         _thread.setRunning(false);

         while (retry) {

             try {

                 _thread.join();

                 retry = false;

             } catch (InterruptedException e) {

                 // we will try it again and again...

             }

         }

}



@Override

public void surfaceChanged(SurfaceHolder holder, int format, int width,

  int height) {

 // TODO Auto-generated method stub



}

}



class DrawingThread extends Thread {

     private SurfaceHolder _surfaceHolder;

     private DrawingPanel _panel;

     private boolean _run = false;



     public DrawingThread(SurfaceHolder surfaceHolder, DrawingPanel panel) {

         _surfaceHolder = surfaceHolder;

         _panel = panel;

     }



     public void setRunning(boolean run) {

         _run = run;

     }



     public SurfaceHolder getSurfaceHolder() {

         return _surfaceHolder;

     }



     @Override

     public void run() {

         Canvas c;

         while (_run) {

             c = null;

             try {

                 c = _surfaceHolder.lockCanvas(null);

                 synchronized (_surfaceHolder) {

                     _panel.onDraw(c);

                 }

             } finally {

                 // do this in a finally so that if an exception is thrown

                 // during the above, we don't leave the Surface in an

                 // inconsistent state

                 if (c != null) {

                     _surfaceHolder.unlockCanvasAndPost(c);

                 }

             }

         }

     }

 }

}

取得LINUX系統記憶體剩餘空間

在linux下，沒用到的記憶體空間會被拿來當作buffer/cache使用，

以加速I/O存取

所以會感覺記憶體占用很多，

其實實際上如果程式需要記憶體，

就會釋放buffer/cache的空間，所以通常記憶體幾乎都是保持在很高的使用量。



使用free指令，

"-/+ buffers/cache"那一行的free就是實際上系統剩下來沒被其他程式吃掉的記憶體大小


可以用以下的指令取得真實的剩餘空間
echo -n free memory:;free -m | grep buffers/cache | awk '{print $4}'

C陣列與指標

宣告陣列時，
無論是幾維的陣列，
C語言都以分配一塊連續的記憶體空間來處理。


所以這種時候，可以把它當一維陣列處理

C以row為主，假設是二維陣列 arr[2][2]
當一維時的順序就是:
arr[0][0] arr[0][1] arr[1][0] arr[1][1]




雖然指標和陣列用起來差不多，
不過實際上意義是不太一樣的，
可以參考
http://dascan.pixnet.net/blog/post/15600458
http://squall.cs.ntou.edu.tw/cprog/Materials/AdvancedArray.html





要宣告一個指標代表陣列，要用以下的方法:

int data[5][5][5][5];
int (*p)[5][5][5];

可以參考
http://blog.udn.com/cchahacaptain/2197712

混合C與C++的程式

參考這個網站的：

http://www.parashift.com/c++-faq-lite/mixing-c-and-cpp.html

在c＋＋的程式內，使用C++標準函式庫，需要標明namespace:

#include <>; //cstdio

int main(){

...

std::printf(...);

...

}

在c＋＋的程式內，使用C標準函式庫，用法跟c一樣:

#include <> //stdio.h

int main(){

...

printf(...);

...

}

在c＋＋的程式內，使用C函式庫:

extern "C" {

#include "" //my-header.h

}

int main(){

...

my_func(...);

...

}

若要同一個header file給c與c＋＋直接使用，也可以在header內加上exter "C"，並判斷目前是c或c＋＋使用

------------------------------

//my-header.h

#ifdef __cplusplus

extern "C" {

#endif

my-function(...);

#ifdef __cplusplus

}

#endif

------------------------------

//main.cpp

#include "" //my-header.h

int main(){

...

my_func(...);

...

}

------------------------------

若不想要include my-header.h，只要使用某幾個c function，可以直接宣告完整的prototype

//main.cpp

extern "C" my_func(int a, int b, int c);

or

//main.cpp

extern "C" {

my_func1(int a, int b, int c);

my_func2(int a, int b, int c);

my_func3(int a, int b, int c);

}

用到時直接用

//main.cpp

my_func1(...);

若要讓c程式call到c的某個function, 使用extern "C"可以使complier將此function給linker的資訊使用c的格式

//my.cpp

extern "C" my_cpp_func(int a, int b);

my_cpp_func(int a, int b){

...

}