public class WeightCurveActivity extends ActivityBase {

	static final String TAG = WeightCurveActivity.class.getName();

	private LinearLayout rootLayout;
	private XYMultipleSeriesRenderer mRenderer;
	private XYMultipleSeriesDataset mDataset = new XYMultipleSeriesDataset();
	
	private int month;
	private Date date;
	private ArrayList<WeightRecord> records;
	private double[] xValues;
	private double[] yValues;

	public void onCreate(Bundle outState) {
		super.onCreate(outState);
		setContentView(R.layout.weight_curve);
		
		handleIntent();
		initRender();
		initData();
		initUI();
	}
	
	private void handleIntent() {
		String dateString = getIntent().getStringExtra(Const.DATE);
		date = DateHelper.parseString(dateString);
	}
	
	private void initRender() {
		mRenderer = buildRenderer();
		setChartSettings(0, 31, 30, 120);
	}
	
	private void initData() {
		month = DateHelper.getMonth(date);
		WeightRecordDao dao = new WeightRecordDao(this);
		records = dao.getMonthLists(date);
		Helper.showLog(TAG, records.size());
		dao.closeDB();
		initValues();
	}
	
	private void initValues() {
		int count = records.size();
		if (count > 0) {
			xValues = new double[count];
			yValues = new double[count];
			for (int i = 0; i < count; i ++) {
				WeightRecord record = records.get(i);
				xValues[i] = DateHelper.getDay(record.record_on);
				yValues[i] = (Math.round(record.weight * 10) / 10.0);
			}
			setXLabel();
		}
	}
	
	private void initUI() {
		addXYSeries(0);

		rootLayout = (LinearLayout) findViewById(R.id.root);
		View view = ChartFactory.getLineChartView(this, mDataset, mRenderer);
		rootLayout.addView(view);
	}
	
	private void setXLabel() {
		mRenderer.setXLabels(0); // 设置X轴标签不显示
		int length = xValues.length;
		for (int i = 0; i < length; i++) {
			mRenderer.addXTextLabel(i * 3 + 1, month + "/" + (int)xValues[i]);
		}
	}
	
	private XYMultipleSeriesRenderer buildRenderer() {
		XYMultipleSeriesRenderer renderer = new XYMultipleSeriesRenderer();
		renderer.setAxisTitleTextSize(16); // 设置坐标轴字体大小
		renderer.setChartTitleTextSize(20); // 设置标题大小
		renderer.setLabelsTextSize(20); // 设置标签字体大小
		renderer.setLegendTextSize(15); // 设置底部曲线说明字体大小
		renderer.setShowGridX(true); // 设置X方向表格显示
		renderer.setShowLegend(false); // 设置底部曲线说明显示
		renderer.setGridColor(Color.LTGRAY); // 设置表格颜色
		renderer.setPointSize(5f);
		renderer.setMargins(new int[] { 30, 40, 10, 30 });
		renderer.setPanEnabled(true, false); // 设置曲线可滑动

		renderer.setApplyBackgroundColor(true); // 设置图表背景
		renderer.setBackgroundColor(Color.TRANSPARENT);

		renderer.setChartTitle("体重曲线");
		renderer.setXTitle("日期");
		renderer.setYTitle("体重");

		renderer.setXLabelsColor(getResources().getColor(
				R.color.main_font_color));
		renderer.setXLabelsAlign(Align.CENTER);
		renderer.setXLabelsPadding(5);
		renderer.setYLabelsColor(0,
				getResources().getColor(R.color.main_font_color));
		renderer.setYLabelsPadding(5);
		renderer.setYLabelsAlign(Align.RIGHT);

		renderer.setAxesColor(Color.GRAY); // 设置坐标轴颜色
		renderer.setMarginsColor(getResources().getColor(R.color.main_bg_color)); // 设置图表周围颜色
		
		renderer.setLabelsColor(Color.GRAY); // 设置标签颜色
		
		XYSeriesRenderer r = new XYSeriesRenderer();
		r.setColor(getResources().getColor(R.color.stress_font_color));
		r.setFillPoints(true);
		r.setPointStyle(PointStyle.CIRCLE);
		renderer.addSeriesRenderer(r);
		r.setDisplayChartValues(true); // 设置显示图表值
		r.setDisplayChartValuesDistance(1);
		r.setChartValuesTextSize(16);
		r.setChartValuesSpacing(10);
		r.setHighlighted(true);
		return renderer;
	}

	private void setChartSettings(double xMin, double xMax, double yMin,
			double yMax) {
		mRenderer.setXAxisMin(xMin); // 设置X轴最小值
		mRenderer.setXAxisMax(xMax); // 设置X轴最大值
		mRenderer.setYAxisMin(yMin); // 设置Y轴最小值
		mRenderer.setYAxisMax(yMax); // 设置Y轴最大值
	}

	private void addXYSeries(int scale) {
		XYSeries series = new XYSeries("", scale);
		if (records.size() > 0) {
			int seriesLength = xValues.length;
			for (int k = 0; k < seriesLength; k++) {
				series.add(k * 3 + 1, yValues[k]);
			}
		}
		mDataset.addSeries(series);
	}
}

public class Foo {
    // 在类被加载进入内存的时候就创建单一的Foo对象
    public static final Foo foo = new Foo();

    // 构造函数私有化
    private Foo() {

    }

    // 提供一个全局的静态方法
    public static Foo getFoo() {
        return foo;
    }
}

// 这种方式在需要使用的时候才实例化
public class Foo {
    private static Foo foo;

    // 构造函数私有化
    private Foo() {

    }

    // 提供一个全局的静态方法
    public static Foo getFoo() {
        if (foo == null) {
            foo = new Foo();
        }
        return foo;
    }
}

public class Foo {
    private static Foo foo;

    // 构造函数私有化
    private Foo() {
    }

    // 提供一个全局的静态方法，使用同步方法
    public static synchronized Foo getFoo() {
        if (foo == null) {
            foo = new Foo();
        }
        return foo;
    }
}

public class Foo {
    private static Foo foo;

    // 构造函数私有化
    private Foo() {
    }

    // 提供一个全局的静态方法
    public static Foo getFoo() {
        if (foo == null) {
            synchronized (Foo.class) {
                if (foo == null) {
            	    foo = new Foo();
                }
            }
        }
        return foo;
    }
}

MyGestureListener.java
public class MyGestureListener implements OnGestureListener {

	static final String TAG = "MyGestureListener";

	private static final int SWIPE_MAX_OFF_PATH = 100;
	private static final int SWIPE_MIN_DISTANCE = 100;
	private static final int SWIPE_THRESHOLD_VELOCITY = 100;
	
	public Context context;
	
	public MyGestureListener(Context context) {
		this.context = context;
	}

	@Override
	public boolean onDown(MotionEvent e) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void onShowPress(MotionEvent e) {
		// TODO Auto-generated method stub
		Log.e(TAG, "onShowPress");
	}

	@Override
	public boolean onSingleTapUp(MotionEvent e) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
			float distanceY) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void onLongPress(MotionEvent e) {
		// TODO Auto-generated method stub
		Log.e(TAG, "onLongPress");
	}

	@Override
	public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
			float velocityY) {
		if (Math.abs(e1.getY() - e2.getY()) > SWIPE_MAX_OFF_PATH)
			return false;

		if ((e1.getX() - e2.getX()) > SWIPE_MIN_DISTANCE
				&& Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
			Log.e(TAG, "onFling left");

		} else if ((e2.getX() - e1.getX()) > SWIPE_MIN_DISTANCE
				&& Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
			Log.e(TAG, "onFling right");
			((Activity) context).finish();
			
		}
		return true;
	}

}

GestureActivity.java
public class GestureActivity extends ActivityBase {

	MyGestureListener listener = new MyGestureListener(this);
	protected GestureDetector gestureDetector = new GestureDetector(listener);
	
	public boolean onTouchEvent(MotionEvent event) {
        if (gestureDetector.onTouchEvent(event))
            return true;
        else  
            return false;
    }
	
}

public boolean dispatchTouchEvent(MotionEvent ev) {
    gestureDetector.onTouchEvent(ev);
    return super.dispatchTouchEvent(ev);
}

MainActivityGroup.java

public class MainActivityGroup extends ActivityGroup implements
		OnCheckedChangeListener {
	private static final String RECORD = "record";
	private static final String CATEGORY = "category";
	private static final String MORE = "more";

	private ActivityGroupManager manager = null;
	private FrameLayout container = null;
	private RadioGroup radioGroup;

	

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.test_main);

		initView();
	}

	private void initView() {
		radioGroup = (RadioGroup) findViewById(R.id.main_radio);
		radioGroup.setOnCheckedChangeListener(this);

		manager = new ActivityGroupManager();
		container = (FrameLayout) findViewById(R.id.container);
		manager.setContainer(container);
		switchActivity(ActivityGroupManager.RECORD_ACTIVITY_VIEW, RECORD, RecordActivity.class);
	}

	@Override
	public void onCheckedChanged(RadioGroup group, int checkedId) {
		switch (checkedId) {
		case R.id.record_button:
			switchActivity(ActivityGroupManager.RECORD_ACTIVITY_VIEW, RECORD, RecordActivity.class);
			break;
		case R.id.category_button:
			switchActivity(ActivityGroupManager.CATEGORY_ACTIVITY_VIEW, CATEGORY, CategoryActivity.class);
			break;
		case R.id.more_button:
			switchActivity(ActivityGroupManager.MORE_AVTIVITY_VIEW, MORE, MoreActivity.class);
			break;
		default:
			break;
		}
	}
	
	private View getActivityView(String activityName, Class<?> activityClass) {
		return getLocalActivityManager().startActivity(activityName,
				new Intent(MainActivityGroup.this, activityClass))
				.getDecorView();
	}

	private void switchActivity(int num, String activityName, Class<?> activityClass) {
		manager.showContainer(num, getActivityView(activityName, activityClass));
	}

}

ActivityGroupManager.java
public class ActivityGroupManager {

	private static final String TAG = "frag_manager";

	public static final int RECORD_ACTIVITY_VIEW = 0;
	public static final int CATEGORY_ACTIVITY_VIEW = 1;
	public static final int MORE_AVTIVITY_VIEW = 2;

	private HashMap<Integer, View> hashMap;
	private ViewGroup container;

	public ActivityGroupManager() {
		hashMap = new HashMap<Integer, View>();
	}

	public void setContainer(ViewGroup container) {
		this.container = container;
	}
	
	public void showContainer(int num, View view) {
		if (!hashMap.containsKey(num)) {
			hashMap.put(num, view);
			container.addView(view);
		}

		for (Iterator<Integer> iter = hashMap.keySet().iterator(); iter.hasNext();) {
			Object key = iter.next();
			View v = hashMap.get(key);
			v.setVisibility(View.INVISIBLE);
		}
		
		view.setVisibility(View.VISIBLE);
	}
}

container.removeAllViews();
container.addView(view);

<?xml version="1.0" encoding="utf-8"?>
<RadioGroup xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/main_radio"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:layout_gravity="bottom|center"
    android:layout_marginBottom="-20dp"
    android:gravity="center"
    android:orientation="horizontal"
    android:padding="0dp" >

    <RadioButton
        android:id="@+id/record_button"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:layout_weight="1.0"
        android:background="@null"
        android:button="@null"
        android:checked="true"
        android:drawableTop="@drawable/main_tab_record_selector"
        android:gravity="center"
        android:tag="record" />

    <RadioButton
        android:id="@+id/category_button"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_weight="1.0"
        android:background="@null"
        android:button="@null"
        android:drawableTop="@drawable/main_tab_category_selector"
        android:gravity="center_horizontal"
        android:tag="category" />

    <RadioButton
        android:id="@+id/more_button"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_weight="1.0"
        android:background="@null"
        android:button="@null"
        android:drawableTop="@drawable/main_tab_more_selector"
        android:gravity="center_horizontal"
        android:tag="more" />

</RadioGroup>

public class MyHandlerActivity extends Activity {
    Button button;
    MyHandler myHandler;

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.handlertest);

        button = (Button) findViewById(R.id.button);
        myHandler = new MyHandler();
        // 当创建一个新的Handler实例时, 它会绑定到当前线程和消息的队列中,开始分发数据
        // Handler有两个作用, (1) : 定时执行Message和Runnalbe 对象
        // (2): 让一个动作,在不同的线程中执行.

        // 它安排消息,用以下方法
        // post(Runnable)
        // postAtTime(Runnable,long)
        // postDelayed(Runnable,long)
        // sendEmptyMessage(int)
        // sendMessage(Message);
        // sendMessageAtTime(Message,long)
        // sendMessageDelayed(Message,long)
      
        // 以上方法以 post开头的允许你处理Runnable对象
        //sendMessage()允许你处理Message对象(Message里可以包含数据,)

        MyThread m = new MyThread();
        new Thread(m).start();
    }

    /**
    * 接受消息,处理消息 ,此Handler会与当前主线程一块运行
    * */

    class MyHandler extends Handler {
        public MyHandler() {
        }

        public MyHandler(Looper L) {
            super(L);
        }

        // 子类必须重写此方法,接受数据
        @Override
        public void handleMessage(Message msg) {
            // TODO Auto-generated method stub
            Log.d("MyHandler", "handleMessage......");
            super.handleMessage(msg);
            // 此处可以更新UI
            Bundle b = msg.getData();
            String color = b.getString("color");
            MyHandlerActivity.this.button.append(color);

        }
    }

    class MyThread implements Runnable {
        public void run() {

            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            Log.d("thread.......", "mThread........");
            Message msg = new Message();
            Bundle b = new Bundle();// 存放数据
            b.putString("color", "我的");
            msg.setData(b);

            MyHandlerActivity.this.myHandler.sendMessage(msg); // 向Handler发送消息,更新UI

        }
    }

}

HandlerThread handlerThread = new HandlerThread("myHandlerThread");  
handlerThread.start();  
handler = new Handler(handlerThread.getLooper());

public class MyThread extends Activity {    
    private Handler handler = null;    
    @Override    
    public void onCreate(Bundle savedInstanceState) {    
        super.onCreate(savedInstanceState);    
        HandlerThread handlerThread = new HandlerThread("myHandlerThread");    
        handlerThread.start();    
        handler = new Handler(handlerThread.getLooper());    
        handler.post(new MyRunnable());    
        System.out.println("Oncreate---The Thread id is :"    
                + Thread.currentThread().getId());    
        setContentView(R.layout.main);    
    }    
    private class MyRunnable implements Runnable {    
        public void run() {    
            System.out.println("Runnable---The Thread is running");    
            System.out.println("Runnable---The Thread id is :"    
                    + Thread.currentThread().getId());    
            try {    
                Thread.sleep(6000);    
            } catch (InterruptedException e) {    
                // TODO Auto-generated catch block    
                e.printStackTrace();    
            }    
        }    
    }    
}