1. 如何解決android系統的12個惱人問題
1. 系統速度逐漸變慢
當你購買了一款配置不俗的全新Android手機，一開始會覺得系統運行速度很流暢，但是隨著時間的推移，系統會變得越來越慢，如果手機需要5秒鍾才能打開網頁瀏覽器，想必很多用戶都會抓狂。幸運的是，你無需坐以待斃，也不用更換手機，只要下載安裝一些支持自動定時清理的應用軟體，就可以解決這個問題。
2. 無休止的通知提醒
Android系統的通知機制十分發達，甚至也被蘋果iOS借鑒，但令人煩惱的是它總是在不停地發出通知內容，在一些特殊場合難免令人尷尬。你可以嘗試在通知設置中手動關閉一些內容，但是無論關閉多少，總是會有新的服務通知蹦出來。所以，最有效的解決方法不是逐個手動關閉通知，而是選擇一個無聲的音頻文件作為默認聲音。
3. 無法擺脫的預裝垃圾軟體
與蘋果iPhone幾乎零預裝的風格不同，大多數Android設備都預裝了一些廠商自家服務或是運營商的定製服務，有些或許是精品，但大部分其實都是一些垃圾軟體，你可能從來不會去使用它們。令人煩惱的是，一些內置應用無法卸載，並且在開機時自動駐留RAM中，影響整體性能。所以，你可以做的是在設置菜單中禁用這些應用，將它們「打入冷宮」。
4. 電池壽命較短
在理想的世界中，你可以使用手機上網、查看電子郵件、進行3D游戲，而電池電量沒有絲毫減少；但殘酷的現實是，如果你用一款Android手機進行以上操作，往往堅持不了一整天就需要充電。如果你願意做出一些取捨，可以通過降低屏幕亮度、禁用背景數據和關閉GPS等操作，來延長電池壽命，而無需購買額外的電池或攜帶型充電器。如果不擔心保修問題，你還可以通過Semaphore內核設置來降低手機的電壓，來獲得更長的續航能力。
5. 沒有更精準的電量顯示功能
大多數Android手機都沒有提供精準的電量顯示功能，所以你無法判斷精準的剩餘電量，從而控制使用強度。如果手機廠商沒有為其配備電池百分比功能，你還可以通過下載第三方應用程序來實現這個功能。
6. 界面效果不美觀
也許你是因為品牌、價格或是其他因素購買了一款Android手機，但並不喜歡它的界面效果，還可以通過安裝第三方界面應用來進行美化，這是蘋果iOS和微軟Windows Phone都不支持的功能。Android領域的第三方界面軟體十分豐富，比如GO桌面EX、國內MIUI等等，基本上都配備了個性化的主題，甚至是自定義的手勢功能，一些界面軟體的運行速度甚至要比原生更為流暢。
7. 獲得其他Android手機的獨家功能
俗話說，得不到的永遠是最好的，有時候你可能會羨慕其他Android手機內置的一些獨家功能，比如LG Optimus G Pro的QSLIDE多任務窗口、三星Galaxy S4的畫中畫視頻播放或是摩托羅拉Droid RAZR的智能操作自動化服務等，其實你完全可以使用第三方應用來實現這些功能。比如在谷歌商店中搜索「浮動應用程序」，就可以找到「漂浮瀏覽器（Floating Browser Flux）」或是「超級視頻（Super Video）」播放器，能夠實現一定程度上的多任務操作功能；另外，類似「Tasker」這樣的系統應用，只要設定一些條件，就可以實現手機自動化操作的功能。
8. 「分享」菜單有太多選項
Android的最佳功能之一是其豐富的分享菜單功能，幾乎列出了所有的可用內容，不過隨著程序安裝的增多，你會發現一些根本用不到的選項，看起來十分礙眼。第三方應用程序「Andmade」可以幫助你解決這個困擾，它可以重新自定義分享菜單，刪除不必要的選項，並根據自己的需求進行重新排列。
9. 解鎖界面太復雜
一些智能手機廠商開始在解鎖界面上添加更多的內容，比如顯示天氣、最常用的應用程序甚至了社交應用的更新內容，但如果你只需要一個簡單迅速的解鎖界面，可以進入系統設置中更改解鎖屏幕的顯示信息。
10. 錯誤的系統默認應用
有時候你想打開Android手機中的一個文件，但卻發現並不是你最希望使用的軟體，這可能是一些應用程序更改了默認的打開方式。與Windows系統一樣，你也可以自行設置系統打開相關文件的默認應用，只需要進入應用程序設置欄目中，清除應用程序的預設值，再次打開相同的文件時，系統就會彈出選項，讓你選擇默認應用，可以根據需求選擇「始終」或是「僅一次」的操作形式。
11. 默認輸入法太難用
通常情況下，Android手機的系統內置輸入法都很糟糕，很難獲得良好的使用體驗。事實上我們依然可以通過下載第三方應用來改變這個情況，在谷歌應用商店中，可以找到一票類似的軟體，比如QQ輸入法，擁有更好的聯想、手機鍵盤效果，也可自定義皮膚，更加符合國人的使用習慣。
12. 過時的Android系統版本
目前Android系統的最新版本是4.2果凍豆，但可能你的手機還是Android 4.0冰淇淋三明治、甚至是更過時的2.3版本。換句話說，你會錯過一些最新的功能，比如谷歌語音助手、詳細的通知內容以及所有適配新系統的應用程序。那麼，除了祈禱手機廠商會在某一天內放出新版固件，你也可以嘗試自行刷機。不過，刷機過程相對復雜一些，有可能會將設備刷成磚頭，並且喪失保修服務。你可以參考一下XDA等專業論壇，一些ROM愛好者提供了相當豐富的自定義固件，並且附有詳細的刷機條件和說明，只要按照步驟正確操作即可。對於已經ROOT過的機型，不僅可以刷自定義固件，甚至還可以超頻，獲得更流暢的使用體驗。
2. Android為什麼要用服務播放音樂不用子線程
1. 對於控制研究媒體播放器，通過本地服務打，不如送媒體播放器參考其他類一樣CarefulMediaPlayer（MP，這一點）;你在處理此類播放器的屬性。我認為它幫助你。 謝謝 2. 我為這個問題掙扎，最後我得到了它的工作班以下。這個想法是一個線程與活套，剩下活著，並處理所有的MediaPlayer的邏輯。 我只退出尺蠖和清理線程，如果服務接收到的明確 public class PlayService extends IntentService { private static PowerManager.WakeLock wakeLock; private static final String TAG = "PlayService"; private static String LOCK_NAME = TAG; public static final String EXTRA_FILE = "file"; public static final String ACTION_PLAY = "play"; private static final String ACTION_STOP = "stop"; public static final int MSG_START = 1; public static final int MSG_STOP = 2; public PlayService(String name) { super(name); } public PlayService() { super("PlayService"); } @Override public void onCreate() { super.onCreate(); } @Override protected void onHandleIntent(Intent intent) { Message msg = new Message(); if (ACTION_PLAY.equalsIgnoreCase(intent.getAction())) { String fileName = intent.getExtras().getString(EXTRA_FILE); msg.what = MSG_START; msg.obj = fileName; } else if (ACTION_STOP.equalsIgnoreCase(intent.getAction())) { msg.what = MSG_STOP; } try { PlayMediaThread.getInstance(this).sendMessage(msg); } catch (InterruptedException e) { Log.e(TAG, e.getMessage()); } } public static PowerManager.WakeLock acquireLock(Context context) { if (wakeLock == null !wakeLock.isHeld()) { PowerManager powerManager = (PowerManager) context .getSystemService(Context.POWER_SERVICE); wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, LOCK_NAME); wakeLock.setReferenceCounted(true); wakeLock.acquire(); } return wakeLock; } public static void releaseLock(Context context) { if (wakeLock != null && wakeLock.isHeld()) { wakeLock.release(); } } } class PlayMediaThread extends Thread implements OnCompletionListener, OnErrorListener, OnPreparedListener { private static Semaphore semaphore = new Semaphore(0); private static Handler handler; private static Looper myLooper; private static Context context; private static String currentFileName; private static MediaPlayer player; private static PlayMediaThread instance; private static final String TAG = "PlayMediaThread"; private PlayMediaThread(Context context) throws InterruptedException { super(TAG); PlayMediaThread.context = context; start(); // To insure that the looper was initialized correctly before return an // instance semaphore.acquire(); } public static PlayMediaThread getInstance(Context context) throws InterruptedException { if (instance == null) { instance = new PlayMediaThread(context); } PlayMediaThread.context = context; return instance; } public void sendMessage(Message msg) { handler.sendMessage(msg); } public void quitLooper() { try { if (myLooper != null) { myLooper.quit(); Log.i(TAG, "After quit"); } } catch (Exception ex) { Log.e(TAG, ex.getMessage()); } } @Override public void run() { Looper.prepare(); myLooper = Looper.myLooper(); handler = new Handler() { @Override public void handleMessage(Message msg) { if (msg.what == PlayService.MSG_START) { startPlayer((String) msg.obj); } else if (msg.what == PlayService.MSG_STOP) { // when stop command is coming from the activity i.e. user // explicitly clicked stop, I quit the looper and // clean the thread stopPlayer(true); } } }; semaphore.release(); Log.i(TAG, "Before Loop"); Looper.loop(); } private void stopPlayer(boolean clean) { if (player != null) { if (player.isPlaying()) { player.stop(); } player.release(); player = null; } if (clean) { PlayService.releaseLock(context); quitLooper(); instance = null; } } private void startPlayer(String fileName) { if (player != null && player.isPlaying() && currentFileName != null && currentFileName.equalsIgnoreCase(fileName)) { return; } currentFileName = fileName; stopPlayer(false); player = new MediaPlayer(); player.setOnCompletionListener(this); player.setOnErrorListener(this); player.setOnPreparedListener(this); try { player.setDataSource(context, Uri.parse(currentFileName)); player.prepare(); player.start(); PlayService.acquireLock(context); } catch (Exception e) { Log.e(TAG, e.getMessage()); } } @Override public boolean onError(MediaPlayer mp, int arg1, int arg2) { Log.e(TAG, "onError"); stopPlayer(true); return false; } @Override public void onCompletion(MediaPlayer mp) { Log.d(TAG, "onCompletion"); // Just to quit the looper and clean the thread stopPlayer(true); } @Override public void onPrepared(MediaPlayer mp) { Log.d(TAG, "onPrepared"); } }
3. 安卓中的Binder架構是什麼為什麼要提供BinderService與Binder又有怎樣的聯系
建議您查找工具書，這么專業的只是怕是解決不了，抱歉，只能粗略的給您解釋一下。Android 整體架構，不識廬山真面目，只緣身在此山中，所以我們先來大概看下 Android 這座大山的整體輪廓。我們先從 Android 的整體架構來看看 Binder 是處於什麼地位，其實很簡單，就是完成一個手機該有的核心功能如簡訊的收發管理、電話的接聽、掛斷以及應用程序的包管理、Activity 的管理等等。
Android 中「應用程序框架層」以 SDK 的形式開放給開發者使用，「系統服務層」中的核心服務隨系統啟動而運行，通過應用層序框架層提供的 Manager 實時為應用程序提供服務調用。系統服務層中每一個服務運行在自己獨立的進程空間中，應用程序框架層中的 Manager 通過 Binder IPC 的方式調用系統服務層中的服務。Binder是Android系統進程間通信（IPC）方式之一 linux已經擁有的進程間通信IPC手段包括(Internet Process Connection)。
管道（Pipe）、信號（Signal）和跟蹤（Trace）、插口（Socket）、報文隊列（Message）、共享內存（Share Memory）和信號量（Semaphore）。本文詳細介紹Binder作為Android主要IPC方式的優勢。
4. Android上某應用喚醒另一應用的方式有多少種
進程中線程同步的四種常用方式：
1、 臨界區（CCriticalSection）
當多個線程訪問一個獨占性共享資源時，可以使用臨界區對象。擁有臨界區的線程可以訪問被保護起來的資源或代碼段，其他線程若想訪問，則被掛起，直到擁有臨界區的線程放棄臨界區為止。具體應用方式：
1、 定義臨界區對象CcriticalSection g_CriticalSection;
2、 在訪問共享資源（代碼或變數）之前，先獲得臨界區對象，g_CriticalSection.Lock（）；
3、 訪問共享資源後，則放棄臨界區對象，g_CriticalSection.Unlock（）；
2、 事件（CEvent）
事件機制，則允許一個線程在處理完一個任務後，主動喚醒另外一個線程執行任務。比如在某些網路應用程序中，一個線程如A負責偵聽通信埠，另外一個線程B負責更新用戶數據，利用事件機制，則線程A可以通知線程B何時更新用戶數據。每個Cevent對象可以有兩種狀態：有信號狀態和無信號狀態。Cevent類對象有兩種類型：人工事件和自動事件。
自動事件對象，在被至少一個線程釋放後自動返回到無信號狀態；
人工事件對象，獲得信號後，釋放可利用線程，但直到調用成員函數ReSet()才將其設置為無信號狀態。在創建Cevent對象時，默認創建的是自動事件。
1、1234CEvent(BOOL bInitiallyOwn=FALSE, BOOL bManualReset=FALSE, LPCTSTR lpszName=NULL, LPSECURITY_ATTRIBUTES lpsaAttribute=NULL);
bInitiallyOwn:指定事件對象初始化狀態，TRUE為有信號，FALSE為無信號；
bManualReset：指定要創建的事件是屬於人工事件還是自動事件。TRUE為人工事件，FALSE為自動事件；
後兩個參數一般設為NULL，在此不作過多說明。
2、BOOL CEvent：：SetEvent();
將Cevent類對象的狀態設置為有信號狀態。如果事件是人工事件，則Cevent類對象保持為有信號狀態，直到調用成員函數ResetEvent()將其重新設為無信號狀態時為止。如果為自動事件，則在SetEvent（）後將事件設置為有信號狀態，由系統自動重置為無信號狀態。
3、BOOL CEvent：：ResetEvent();
將事件的狀態設置為無信號狀態，並保持該狀態直至SetEvent（）被調用為止。由於自動事件是由系統自動重置，故自動事件不需要調用該函數。
一般通過調用WaitForSingleObject（）函數來監視事件狀態。
3、 互斥量（CMutex）
互斥對象和臨界區對象非常相似，只是其允許在進程間使用，而臨界區只限制與同一進程的各個線程之間使用，
但是更節省資源，更有效率。
4、 信號量（CSemphore）
當需要一個計數器來限制可以使用某共享資源的線程數目時，可以使用「信號量」對象。CSemaphore類對象保存了對當前訪問某一個指定資源的線程的計數值，該計數值是當前還可以使用該資源的線程數目。如果這個計數達到了零，則所有對這個CSemaphore類對象所控制的資源的訪問嘗試都被放入到一個隊列中等待，直到超時或計數值不為零為止。
CSemaphore(
LONG lInitialCount = 1,
LONG lMaxCount = 1,
LPCTSTR pstrName = NULL,
LPSECURITY_ATTRIBUTES lpsaAttributes = NULL
);
lInitialCount:信號量對象的初始計數值，即可訪問線程數目的初始值；
lMaxCount：信號量對象計數值的最大值，該參數決定了同一時刻可訪問由信號量保護的資源的線程最大數目；
後兩個參數在同一進程中使用一般為NULL，不作過多討論；
一般是將當前可用資源計數設置為最大資源計數，每增加一個線程對共享資源的訪問，當前可用資源計數就減1，只要當前可用資源計數大於0，就可以發出信號量信號。如果為0，則放入一個隊列中等待。線程在處理完共享資源後，應在離開的同時通過ReleaseSemaphore（）函數將當前可用資源數加1。
BOOL ReleaseSemaphore( HANDLE hSemaphore, // hSemaphore:信號量句柄
LONG lReleaseCount, // lReleaseCount：信號量計數值
LPLONG lpPreviousCount // 參數一般為NULL);
5. android里音樂沒播放怎麼也調用setoncompletionlistener
1.對於控制研究媒體播放器，通過本地服務打，不如送媒體播放器參考其他類一樣CarefulMediaPlayer（MP，這一點）;你在處理此類播放器的屬性。我認為它幫助你。 謝謝
2.我為這個問題掙扎，最後我得到了它的工作班以下。這個想法是一個線程與活套，剩下活著，並處理所有的MediaPlayer的邏輯。 我只退出尺蠖和清理線程，如果服務接收到的明確
java">{
privatestaticPowerManager.WakeLockwakeLock;
privatestaticfinalStringTAG="PlayService";
privatestaticStringLOCK_NAME=TAG;
publicstaticfinalStringEXTRA_FILE="file";
publicstaticfinalStringACTION_PLAY="play";
_STOP="stop";
publicstaticfinalintMSG_START=1;
publicstaticfinalintMSG_STOP=2;
publicPlayService(Stringname){
super(name);
}
publicPlayService(){
super("PlayService");
}
@Override
publicvoidonCreate(){
super.onCreate();
}
@Override
protectedvoidonHandleIntent(Intentintent){
Messagemsg=newMessage();
if(ACTION_PLAY.equalsIgnoreCase(intent.getAction())){
StringfileName=intent.getExtras().getString(EXTRA_FILE);
msg.what=MSG_START;
msg.obj=fileName;
}elseif(ACTION_STOP.equalsIgnoreCase(intent.getAction())){
msg.what=MSG_STOP;
}
try{
PlayMediaThread.getInstance(this).sendMessage(msg);
}catch(InterruptedExceptione){
Log.e(TAG,e.getMessage());
}
}
publicstaticPowerManager.WakeLockacquireLock(Contextcontext){
if(wakeLock==null||!wakeLock.isHeld()){
PowerManagerpowerManager=(PowerManager)context
.getSystemService(Context.POWER_SERVICE);
wakeLock=powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
LOCK_NAME);
wakeLock.setReferenceCounted(true);
wakeLock.acquire();
}
returnwakeLock;
}
publicstaticvoidreleaseLock(Contextcontext){
if(wakeLock!=null&&wakeLock.isHeld()){
wakeLock.release();
}
}
}
,
OnErrorListener,OnPreparedListener{
=newSemaphore(0);
privatestaticHandlerhandler;
privatestaticLoopermyLooper;
privatestaticContextcontext;
;
;
;
privatestaticfinalStringTAG="PlayMediaThread";
privatePlayMediaThread(Contextcontext)throwsInterruptedException{
super(TAG);
PlayMediaThread.context=context;
start();
//
//instance
semaphore.acquire();
}
(Contextcontext)
throwsInterruptedException{
if(instance==null){
instance=newPlayMediaThread(context);
}
PlayMediaThread.context=context;
returninstance;
}
publicvoidsendMessage(Messagemsg){
handler.sendMessage(msg);
}
publicvoidquitLooper(){
try{
if(myLooper!=null){
myLooper.quit();
Log.i(TAG,"Afterquit");
}
}catch(Exceptionex){
Log.e(TAG,ex.getMessage());
}
}
@Override
publicvoidrun(){
Looper.prepare();
myLooper=Looper.myLooper();
handler=newHandler(){
@Override
publicvoidhandleMessage(Messagemsg){
if(msg.what==PlayService.MSG_START){
startPlayer((String)msg.obj);
}elseif(msg.what==PlayService.MSG_STOP){
//.e.user
//explicitlyclickedstop,Iquitthelooperand
//cleanthethread
stopPlayer(true);
}
}
};
semaphore.release();
Log.i(TAG,"BeforeLoop");
Looper.loop();
}
privatevoidstopPlayer(booleanclean){
if(player!=null){
if(player.isPlaying()){
player.stop();
}
player.release();
player=null;
}
if(clean){
PlayService.releaseLock(context);
quitLooper();
instance=null;
}
}
privatevoidstartPlayer(StringfileName){
if(player!=null&&player.isPlaying()&¤tFileName!=null
&¤tFileName.equalsIgnoreCase(fileName)){
return;
}
currentFileName=fileName;
stopPlayer(false);
player=newMediaPlayer();
player.setOnCompletionListener(this);
player.setOnErrorListener(this);
player.setOnPreparedListener(this);
try{
player.setDataSource(context,Uri.parse(currentFileName));
player.prepare();
player.start();
PlayService.acquireLock(context);
}catch(Exceptione){
Log.e(TAG,e.getMessage());
}
}
@Override
publicbooleanonError(MediaPlayermp,intarg1,intarg2){
Log.e(TAG,"onError");
stopPlayer(true);
returnfalse;
}
@Override
publicvoidonCompletion(MediaPlayermp){
Log.d(TAG,"onCompletion");
//
stopPlayer(true);
}
@Override
publicvoidonPrepared(MediaPlayermp){
Log.d(TAG,"onPrepared");
}
}
6. 畢業設計選了用android做一個3d魔方的游戲，應為android以前沒接觸過的，要從頭開始學的。這個難嗎高手
只要java好就沒有問題，這是3D魔方android的源碼。
package com.example.android.image3D;
import android.view.SurfaceView;
import android.view.SurfaceHolder;
import android.content.Context;
import android.util.AttributeSet;
import java.util.ArrayList;
import java.util.concurrent.Semaphore;
import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGL11;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;
import javax.microedition.khronos.egl.EGLSurface;
import javax.microedition.khronos.opengles.GL;
import javax.microedition.khronos.opengles.GL10;
public class View3D extends SurfaceView implements SurfaceHolder.Callback {
private static final Semaphore sEglSemaphore = new Semaphore(1);
private boolean mSizeChanged = true;
private SurfaceHolder mHolder;
private GLThread mGLThread;
private GLWrapper mGLWrapper;
public View3D(Context context) {
super(context);
init();
}
public View3D(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
private void init() {
mHolder = getHolder();
mHolder.addCallback(this);
mHolder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
}
public SurfaceHolder getSurfaceHolder() {
return mHolder;
}
public void setGLWrapper(GLWrapper glWrapper) {
mGLWrapper = glWrapper;
}
public void setRenderer(Renderer renderer) {
mGLThread = new GLThread(renderer);
mGLThread.start();
}
public void surfaceCreated(SurfaceHolder holder) {
mGLThread.surfaceCreated();
}
public void surfaceDestroyed(SurfaceHolder holder) {
mGLThread.surfaceDestroyed();
}
public void surfaceChanged(SurfaceHolder holder,
int format, int w, int h) {
mGLThread.onWindowResize(w, h);
}
public void onPause() {
mGLThread.onPause();
}
public void onResume() {
mGLThread.onResume();
}
@Override
public void onWindowFocusChanged(boolean hasFocus) {
super.onWindowFocusChanged(hasFocus);
mGLThread.onWindowFocusChanged(hasFocus);
}
public void queueEvent(Runnable r) {
mGLThread.queueEvent(r);
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
mGLThread.requestExitAndWait();
}
public interface GLWrapper {
GL wrap(GL gl);
}
public interface Renderer {
int[] getConfigSpec();
void surfaceCreated(GL10 gl);
void sizeChanged(GL10 gl, int width, int height);
void drawFrame(GL10 gl);
}
private class EglHelper {
EGL10 mEgl;
EGLDisplay mEglDisplay;
EGLSurface mEglSurface;
EGLConfig mEglConfig;
EGLContext mEglContext;
public EglHelper() {
}
public void start(int[] configSpec){
mEgl = (EGL10) EGLContext.getEGL();
mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
int[] version = new int[2];
mEgl.eglInitialize(mEglDisplay, version);
EGLConfig[] configs = new EGLConfig[1];
int[] num_config = new int[1];
mEgl.eglChooseConfig(mEglDisplay, configSpec, configs, 1,
num_config);
mEglConfig = configs[0];
mEglContext = mEgl.eglCreateContext(mEglDisplay, mEglConfig,
EGL10.EGL_NO_CONTEXT, null);
mEglSurface = null;
}
public GL createSurface(SurfaceHolder holder) {
if (mEglSurface != null) {
mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
}
mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay,
mEglConfig, holder, null);
mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
mEglContext);
GL gl = mEglContext.getGL();
if (mGLWrapper != null) {
gl = mGLWrapper.wrap(gl);
}
return gl;
}
public boolean swap() {
mEgl.eglSwapBuffers(mEglDisplay, mEglSurface);
return mEgl.eglGetError() != EGL11.EGL_CONTEXT_LOST;
}
public void finish() {
if (mEglSurface != null) {
mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_CONTEXT);
mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
mEglSurface = null;
}
if (mEglContext != null) {
mEgl.eglDestroyContext(mEglDisplay, mEglContext);
mEglContext = null;
}
if (mEglDisplay != null) {
mEgl.eglTerminate(mEglDisplay);
mEglDisplay = null;
}
}
}
class GLThread extends Thread {
private boolean mDone;
private boolean mPaused;
private boolean mHasFocus;
private boolean mHasSurface;
private boolean mContextLost;
private int mWidth;
private int mHeight;
private Renderer mRenderer;
private ArrayList<Runnable>
mEventQueue = new ArrayList<Runnable>();
private EglHelper mEglHelper;
GLThread(Renderer renderer) {
super();
mDone = false;
mWidth = 0;
mHeight = 0;
mRenderer = renderer;
setName("GLThread");
}
@Override
public void run() {
try {
try {
sEglSemaphore.acquire();
} catch (InterruptedException e) {
return;
}
guardedRun();
} catch (InterruptedException e) {
} finally {
sEglSemaphore.release();
}
}
private void guardedRun() throws InterruptedException {
mEglHelper = new EglHelper();
int[] configSpec = mRenderer.getConfigSpec();
mEglHelper.start(configSpec);
GL10 gl = null;
boolean tellRendererSurfaceCreated = true;
boolean tellRendererSurfaceChanged = true;
while (!mDone) {
int w, h;
boolean changed;
boolean needStart = false;
synchronized (this) {
Runnable r;
while ((r = getEvent()) != null) {
r.run();
}
if (mPaused) {
mEglHelper.finish();
needStart = true;
}
if(needToWait()) {
while (needToWait()) {
wait();
}
}
if (mDone) {
break;
}
changed = mSizeChanged;
w = mWidth;
h = mHeight;
mSizeChanged = false;
}
if (needStart) {
mEglHelper.start(configSpec);
tellRendererSurfaceCreated = true;
changed = true;
}
if (changed) {
gl = (GL10) mEglHelper.createSurface(mHolder);
tellRendererSurfaceChanged = true;
}
if (tellRendererSurfaceCreated) {
mRenderer.surfaceCreated(gl);
tellRendererSurfaceCreated = false;
}
if (tellRendererSurfaceChanged) {
mRenderer.sizeChanged(gl, w, h);
tellRendererSurfaceChanged = false;
}
if ((w > 0) && (h > 0)) {
mRenderer.drawFrame(gl);
mEglHelper.swap();
}
}
mEglHelper.finish();
}
private boolean needToWait() {
return (mPaused || (! mHasFocus) || (! mHasSurface) || mContextLost)
&& (! mDone);
}
public void surfaceCreated() {
synchronized(this) {
mHasSurface = true;
mContextLost = false;
notify();
}
}
public void surfaceDestroyed() {
synchronized(this) {
mHasSurface = false;
notify();
}
}
public void onPause() {
synchronized (this) {
mPaused = true;
}
}
public void onResume() {
synchronized (this) {
mPaused = false;
notify();
}
}
public void onWindowFocusChanged(boolean hasFocus) {
synchronized (this) {
mHasFocus = hasFocus;
if (mHasFocus == true) {
notify();
}
}
}
public void onWindowResize(int w, int h) {
synchronized (this) {
mWidth = w;
mHeight = h;
mSizeChanged = true;
}
}
public void requestExitAndWait() {
synchronized(this) {
mDone = true;
notify();
}
try {
join();
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
}
public void queueEvent(Runnable r) {
synchronized(this) {
mEventQueue.add(r);
}
}
private Runnable getEvent() {
synchronized(this) {
if (mEventQueue.size() > 0) {
return mEventQueue.remove(0);
}
}
return null;
}
}
}
7. 淺談linux進程之間是如何通信的
有足夠許可權的進程可以向隊列中添加消息，被賦予讀許可權的進程則可以讀走隊列中的消息。消息隊列克服了信號承載信息量少，管道只能承載無格式位元組流以及緩沖區大小受限等缺點；【java培訓】 2、管道（Pipe）及有名管道（named pipe）：管道可用於具有親緣關系進程間的通信，有名管道克服了管道沒有名字的限制，因此，除具有管道所具有的功能外，它還允許無親緣關系進程間的通信； 3、套介面（Socket）：更為一般的進程間通信機制，可用於不同機器之間的進程間通信。起初是由Unix系統的BSD分支開發出來的，但現在一般可以移植到其它類Unix系統上：Linux和System V的變種都支持套接字；【學習java】 4、信號（Signal）：信號是比較復雜的通信方式，用於通知接受進程有某種事件發生，除了用於進程間通信外，進程還可以發送信號給進程本身；linux除了支持Unix早期信號語義函數sigal外，還支持語義符合Posix.1標準的信號函數sigaction（實際上，該函數是基於BSD的，BSD為了實現可靠信號機制，又能夠統一對外介面，用sigaction函數重新實現了signal函數）； 5、共享內存：使得多個進程可以訪問同一塊內存空間，是最快的可用IPC形式。是針對其他通信機制運行效率較低而設計的。往往與其它通信機制，如信號量結合使用，來達到進程間的同步及互斥；【java學習】 6、信號量（semaphore）：主要作為進程間以及同一進程不同線程之間的同步手段。 以上就是linux操作系統下進程之間的通信講解，希望對廣大學習者有所幫助。 騰科IT教育軟體學院是騰科IT教育集團旗下的全資子公司,是一家專業從事Java, Android, Oracle Java, Linux Java, 系統架構師等高端IT技能培訓的專業機構。也是甲骨文授權的廣州唯一一家正版Oracle Java學習中心！秉承六年辦學理念，致力於提供全球領先的培訓方案，著力打造IT行業精英人才。學校位於廣州最繁華的金融商業中心天河區，地理位置優越，學校環境優美，教學設施完備，師資力量雄厚。