android 2.2 apidemos 赏析笔记 6

[size=x-large]SearchInvoke.java[/size]
[url=http://www.imobilebbs.com/wordpress/?p=1231]传送门[/url]
这个。。。
这里只是一个调用GOOGLE的searchUI的一个范例，不是具体实现什么功能，和menu键一样，那个搜索键的相关功能设置

SEE:
1.
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
super.onPrepareOptionsMenu(menu);
menu.removeItem(0);
menu.removeItem(1);
return true;
}
SO:
此函数可以动态的修改MENU菜单，onCreateOptionMenu不能动态修改？

SEE:
1.
Bundle appDataBundle = null;
final String queryAppDataString = mQueryAppData.getText().toString();
if (queryAppDataString != null) {
appDataBundle = new Bundle();
appDataBundle.putString("demo_key", queryAppDataString);
}
startSearch(queryPrefill, false, appDataBundle, false);
SO:
这样搜索UI调用结束。

SEE:
1.AndroidManifest.xml
<activity android:name=".app.SearchInvoke"
android:label="@string/search_invoke">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.SAMPLE_CODE" />
</intent-filter>

<meta-data android:name="android.app.default_searchable"
android:value=".app.SearchQueryResults" />
</activity>
2.
<activity android:name=".app.SearchQueryResults"
android:label="@string/search_query_results">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.SAMPLE_CODE" />
</intent-filter>

<intent-filter>
<action android:name="android.intent.action.SEARCH" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>

<meta-data android:name="android.app.searchable"
android:resource="@xml/searchable" />
</activity>
<provider android:name=".app.SearchSuggestionSampleProvider"
android:authorities="com.example.android.apis.SuggestionProvider" />
3.
<searchable xmlns:android="http://schemas.android.com/apk/res/android"
android:label="@string/search_label"
android:hint="@string/search_hint"
android:searchMode="showSearchLabelAsBadge"

android:voiceSearchMode="showVoiceSearchButton|launchRecognizer"
android:voiceLanguageModel="free_form"
android:voicePromptText="@string/search_invoke"

android:searchSuggestAuthority="com.example.android.apis.SuggestionProvider"
android:searchSuggestSelection=" ? "
/>
SO:
1.meta-data 变化的数据，来设定响应的activity
2.设定resource 和
3.设定某些东西，我关注的是android:searchSuggestAuthorit="com.example.android.apis.SuggestionProvider"

SEE:SearchQueryResults.JAVA
1.
final Intent queryIntent = getIntent();
final String queryAction = queryIntent.getAction();
if (Intent.ACTION_SEARCH.equals(queryAction)) {
doSearchQuery(queryIntent, "onCreate()");
}
else {
mDeliveredByText.setText("onCreate(), but no ACTION_SEARCH intent");
}
2.
private void doSearchQuery(final Intent queryIntent, final String entryPoint) {
final String queryString = queryIntent.getStringExtra(SearchManager.QUERY);
mQueryText.setText(queryString);
3.
SearchRecentSuggestions suggestions = new SearchRecentSuggestions(this,
SearchSuggestionSampleProvider.AUTHORITY, SearchSuggestionSampleProvider.MODE);
suggestions.saveRecentQuery(queryString, null);
4.
final Bundle appData = queryIntent.getBundleExtra(SearchManager.APP_DATA);
if (appData == null) {
mAppDataText.setText("<no app data bundle>");
}
if (appData != null) {
String testStr = appData.getString("demo_key");
mAppDataText.setText((testStr == null) ? "<no app data>" : testStr);
}
5.
public void onNewIntent(final Intent newIntent) {
super.onNewIntent(newIntent);

// get and process search query here
final Intent queryIntent = getIntent();
final String queryAction = queryIntent.getAction();
if (Intent.ACTION_SEARCH.equals(queryAction)) {
doSearchQuery(queryIntent, "onNewIntent()");
}
else {
mDeliveredByText.setText("onNewIntent(), but no ACTION_SEARCH intent");
}
}
SO:
1.
判断启动该ACTIVITY的INTENT的ACTION，判断是由搜索启动的还是直接启动的
2.
获得第一个默认的字符串 startSearch(queryPrefill, false, appDataBundle, false);
3
获得指定的suggestion,参数为，this,名字，模式。保存该搜索。
4.
获取附加的数据,key为"demo_key"
5.
当activity已经打开的时候，接受到新的INTENT重启的时候调用的方法。

SEE:
1.SearchSuggestionSampleProvider .java
public class SearchSuggestionSampleProvider extends SearchRecentSuggestionsProvider {
final static String AUTHORITY = "com.example.android.apis.SuggestionProvider";
final static int MODE = DATABASE_MODE_QUERIES;
public SearchSuggestionSampleProvider() {
super();
setupSuggestions(AUTHORITY, MODE);
}
}
SO:
setupSuggestions(AUTHORITY, MODE);创建相应名字，模式的suggestion以供调用吧


[size=x-large]ForegroundService.java[/size]
SEE:
1.
<service android:name=".app.ForegroundService" />

<activity android:name=".app.ForegroundService$Controller"
android:label="@string/activity_foreground_service_controller"
android:launchMode="singleTop">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.SAMPLE_CODE" />
</intent-filter>
</activity>
2.
ForegroundService$Controller
SO:
使用内部类的ACTIVITY 第二次。这真奇怪为SERVICE服务的 ACTIVITY

SEE:
1.
Intent intent = new Intent(ForegroundService.ACTION_FOREGROUND);
intent.setClass(Controller.this, ForegroundService.class);
startService(intent);
2.
Intent intent = new Intent(ForegroundService.ACTION_BACKGROUND);
intent.setClass(Controller.this, ForegroundService.class);
startService(intent);
3.
stopService(new Intent(Controller.this,
ForegroundService.class));
SO:
开始service和结束Service都用的Intent

SEE:
1.
public void onStart(Intent intent, int startId) {
handleCommand(intent);
}
2.
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
handleCommand(intent);
// We want this service to continue running until it is explicitly
// stopped, so return sticky.
return START_STICKY;
}
3.
void handleCommand(Intent intent) {
if (ACTION_FOREGROUND.equals(intent.getAction())) {
// In this sample, we'll use the same text for the ticker and the expanded notification
CharSequence text = getText(R.string.foreground_service_started);

// Set the icon, scrolling text and timestamp
Notification notification = new Notification(R.drawable.stat_sample, text,
System.currentTimeMillis());

// The PendingIntent to launch our activity if the user selects this notification
PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
new Intent(this, Controller.class), 0);

// Set the info for the views that show in the notification panel.
notification.setLatestEventInfo(this, getText(R.string.local_service_label),
text, contentIntent);

startForegroundCompat(R.string.foreground_service_started, notification);

} else if (ACTION_BACKGROUND.equals(intent.getAction())) {
stopForegroundCompat(R.string.foreground_service_started);
}
}
SO:
1.startService会调用onStart
2.onStartCommand,我们希望这个Service持续运行，直到明确的停止，所以应返回一个stricky
3.
设置一个notification和一个id，通过某种方式来启动notification


SEE:
private static final Class[] mStartForegroundSignature = new Class[] {
int.class, Notification.class};
private static final Class[] mStopForegroundSignature = new Class[] {
boolean.class};
private Method mStartForeground;
private Method mStopForeground;
private Object[] mStartForegroundArgs = new Object[2];
private Object[] mStopForegroundArgs = new Object[1];

1.
try {
mStartForeground = getClass().getMethod("startForeground",
mStartForegroundSignature);
mStopForeground = getClass().getMethod("stopForeground",
mStopForegroundSignature);
} catch (NoSuchMethodException e) {
// Running on an older platform.
mStartForeground = mStopForeground = null;
}
2.
if (mStartForeground != null) {
mStartForegroundArgs[0] = Integer.valueOf(id);
mStartForegroundArgs[1] = notification;
try {
mStartForeground.invoke(this, mStartForegroundArgs);
} catch (InvocationTargetException e) {
// Should not happen.
Log.w("ApiDemos", "Unable to invoke startForeground", e);
} catch (IllegalAccessException e) {
// Should not happen.
Log.w("ApiDemos", "Unable to invoke startForeground", e);
}
return;
}

// Fall back on the old API.
setForeground(true);
mNM.notify(id, notification);
3.
mNM.cancel(id);
setForeground(false);
SO:
1.
getClass().getMethod()，通过名字与特征参数来获取该类的某个方法。startForeground() 有可能存在或者不存在。我们希望优先调用service提供的startForeground()。通过 Method 保持引用。
2.
mStartForeground.invoke(this, mStartForegroundArgs);调用方法。如果不存在在使用自己的NM
3.
后台运行自行设置的方法，这里应该是走的是SERVICE的stopForeground

[size=x-large]LocalServiceActivities.java[/size]
SEE:LocalServiceActivities$LocalServiceActivities
1.
bindService(new Intent(Binding.this,
LocalService.class), mConnection, Context.BIND_AUTO_CREATE);
2.
unbindService(mConnection);
3.
private ServiceConnection mConnection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
mBoundService = ((LocalService.LocalBinder)service).getService();
Toast.makeText(Binding.this, R.string.local_service_connected,
Toast.LENGTH_SHORT).show();
}

public void onServiceDisconnected(ComponentName className) {
mBoundService = null;
Toast.makeText(Binding.this, R.string.local_service_disconnected,
Toast.LENGTH_SHORT).show();
}
};

SO:
1.绑定服务
2.取消服务
3.应该算是一个监听吧 外带Context.BIND_AUTO_CREATE

SEE:LocalServiceActivities$Controller
1.
startService(new Intent(Controller.this,
LocalService.class));
2.
stopService(new Intent(Controller.this,
LocalService.class));
SO:
额，startService Activity退出的时候 Service不中断， bindService Activity退出的时候Service一起中断。完毕。懒的要死。两个放在一起做内部类。虽然可以对比


[size=x-large]MessengerServiceActivities.java[/size]

SEE:
private ServiceConnection mConnection = new ServiceConnection() {
1.
bindService(new Intent(Binding.this,
MessengerService.class), mConnection, Context.BIND_AUTO_CREATE);
2.
unbindService(mConnection);
SO:
绑定MessengerService，和取消MessengerService。复习


SEE:
1.
class IncomingHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MessengerService.MSG_SET_VALUE:
mCallbackText.setText("Received from service: " + msg.arg1);
break;
default:
super.handleMessage(msg);
}
}
}
2.
final Messenger mMessenger = new Messenger(new IncomingHandler());
3.
mService = new Messenger(service);

Message msg = Message.obtain(null,
MessengerService.MSG_REGISTER_CLIENT);
msg.replyTo = mMessenger;
mService.send(msg);
4.
msg = Message.obtain(null,
MessengerService.MSG_SET_VALUE, this.hashCode(), 0);
mService.send(msg);
SO:
1.
获得输入的句柄。handler
2.
Create a new Messenger pointing to the given Handler. Any Message objects sent through this Messenger will appear in the Handler as if Handler.sendMessage(Message) had been called directly.
也就是说 使用该Messenger等同于想Handler.sendMessage()
3.
同绑定一个Handler一样绑定一个IBander,这里的IBander应该是MessengerService。
由于已经有绑定的， Message.obtain(Handler，int)这里的Handler设为NULL。然后通过mService.send()就好。
4.
同3这里多指定了一些东西。

SEE:MessengerService.JAVA
ArrayList<Messenger> mClients = new ArrayList<Messenger>();
1.
class IncomingHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_REGISTER_CLIENT:
mClients.add(msg.replyTo);
break;
case MSG_UNREGISTER_CLIENT:
mClients.remove(msg.replyTo);
break;
case MSG_SET_VALUE:
mValue = msg.arg1;
for (int i=mClients.size()-1; i>=0; i--) {
try {
mClients.get(i).send(Message.obtain(null,
MSG_SET_VALUE, mValue, 0));
} catch (RemoteException e) {
// The client is dead. Remove it from the list;
// we are going through the list from back to front
// so this is safe to do inside the loop.
mClients.remove(i);
}
}
break;
default:
super.handleMessage(msg);
}
}
}
SO:
1.这里负责响应上一块发送的消息。
2.保存msg带来的replyTo
3.收到消息的时候，逐一对mClients进行发送消息。
4.注意到里面有个mClients.remove的动作。由于是由后向前的一个遍历，不会导致删除后，size变化，而出错。


[size=x-large]RemoteService.java[/size]


SEE:RemoteService$Binding
1.
bindService(new Intent(IRemoteService.class.getName()),
mConnection, Context.BIND_AUTO_CREATE);
bindService(new Intent(ISecondary.class.getName()),
mSecondaryConnection, Context.BIND_AUTO_CREATE);
2.IRemoteService.java
* This file is auto-generated. DO NOT MODIFY.
3.
<service android:name=".app.RemoteService" android:process=":remote">
<intent-filter>
<!-- These are the interfaces supported by the service, which
you can bind to. -->
<action android:name="com.example.android.apis.app.IRemoteService" />
<action android:name="com.example.android.apis.app.ISecondary" />
<!-- This is an action code you can use to select the service
without explicitly supplying the implementation class. -->
<action android:name="com.example.android.apis.app.REMOTE_SERVICE" />
</intent-filter>
</service>
SO:
1.这是一个AIDL的范例。这里的intent(getname())=intent("com.example.android.apis.app.IRemoteService"),指其支持的某一个接口，
2.
IRemoteService是由ADT自动根据IRemoteService.aidl自动生成的
3.
这个服务允许绑定的几个接口。这几个接口的Intent绑定的实际上都是这个service。

SEE:RemoteService$Binding
1.
mService = IRemoteService.Stub.asInterface(service);
2.
mService.registerCallback(mCallback);
3.
private IRemoteServiceCallback mCallback = new IRemoteServiceCallback.Stub() {
public void valueChanged(int value) {
mHandler.sendMessage(mHandler.obtainMessage(BUMP_MSG, value, 0));
}
};
4.
private Handler mHandler = new Handler() {
@Override public void handleMessage(Message msg) {
switch (msg.what) {
case BUMP_MSG:
mCallbackText.setText("Received from service: " + msg.arg1);
break;
default:
super.handleMessage(msg);
}
}

};
SO:
1.这里的接口实例，是自动生成的
2.注册CALLBACK
3.new以个重写过valueChanged()的callback
4.Activity主进程的Handler,用来更新组件

SEE:RemoteService$Binding
1.
mSecondaryService = ISecondary.Stub.asInterface(service);
SO:
同上
解释
建立AIDL服务要比建立普通的服务复杂一些，具体步骤如下：
　　（1）在Eclipse Android工程的Java包目录中建立一个扩展名为aidl的文件。该文件的语法类似于Java代码，但会稍有不同。详细介绍见实例的内容。
　　（2）如果aidl文件的内容是正确的，ADT会自动生成一个Java接口文件（*.java）。
　　（3）建立一个服务类（Service的子类）。
　　（4）实现由aidl文件生成的Java接口。
　　（5）在AndroidManifest.xml文件中配置AIDL服务，尤其要注意的是，<action>标签中android:name的属性值就是客户端要引用该服务的ID，也就是Intent类的参数值。


SEE com.example.android.apis.app.xxxx.aidl
1.
interface IRemoteService {
/**
* Often you want to allow a service to call back to its clients.
* This shows how to do so, by registering a callback interface with
* the service.
*/
void registerCallback(IRemoteServiceCallback cb);

/**
* Remove a previously registered callback interface.
*/
void unregisterCallback(IRemoteServiceCallback cb);
}

2.
oneway interface IRemoteServiceCallback {
/**
* Called when the service has a new value for you.
*/
void valueChanged(int value);
}
3.
interface ISecondary {
/**
* Request the PID of this service, to do evil things with it.
*/
int getPid();

/**
* This demonstrates the basic types that you can use as parameters
* and return values in AIDL.
*/
void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
double aDouble, String aString);
}

SO;
AIDL:Android Interface Definition Language,即Android接口描述语言。Android系统中的进程之间不能共享内存，因此，需要提供一些机制在不同进程之间进行数据通信。
1.这里定义了两个接口，其具体的实现在 RemoteService 中，这里只是提供封装好的接口，虽然是两个不同的接口，但实现的地方去是在同一个地方。接口的作用。所以当KILLPROCESS的时候KILL的是同一个PROCESS。。
2.oneway 表示服务将不会中断来等待客户响应。
3.两个方法。一个貌似没用。

SEE:RemoteService.java
0.
final RemoteCallbackList<IRemoteServiceCallback> mCallbacks
= new RemoteCallbackList<IRemoteServiceCallback>();
1.
mHandler.sendEmptyMessage(REPORT_MSG);
2.
private final Handler mHandler = new Handler() {
@Override public void handleMessage(Message msg) {
switch (msg.what) {

// It is time to bump the value!
case REPORT_MSG: {
// Up it goes.
int value = ++mValue;

// Broadcast to all clients the new value.
final int N = mCallbacks.beginBroadcast();
for (int i=0; i<N; i++) {
try {
mCallbacks.getBroadcastItem(i).valueChanged(value);
} catch (RemoteException e) {
// The RemoteCallbackList will take care of removing
// the dead object for us.
}
}
mCallbacks.finishBroadcast();

// Repeat every 1 second.
sendMessageDelayed(obtainMessage(REPORT_MSG), 1*1000);
} break;
default:
super.handleMessage(msg);
}
}
};
SO:
0.
RemoteCallbackList
1.
sendEmptyMessage() Sends a Message containing only the what value.
2.
这就是数字递增的地方。。，和broadcast的地方。


SEE:
总结
SO:
1.写好aidl文件，然后由ADT进行自动创建JAVA文件。
2.在AndroidManifest.xml中注册某个service为响应其ACTION。
3.在SERVICE中实现接口定义的方法。
4.在客户端中调用响应的接口来进行操作，而不需要知道具体由哪个SERVICE实现的。。
5.完。。这个东西省到极点了，像解迷一样。。如果你弄懂了，恭喜解谜成功。


SEE: RemoteService.Controller.JAVA
1.
startService(new Intent(
"com.example.android.apis.app.REMOTE_SERVICE"));
2.AndroidManifest.xml
直接启动 <action android:name="com.example.android.apis.app.REMOTE_SERVICE" />
SO:
直接启动SERVICE，进行notification的显示，无其他功能。
SO EASY。

[size=x-large]ServiceStartArguments.java[/size]

SEE:
1.
HandlerThread thread = new HandlerThread("ServiceStartArguments",
Process.THREAD_PRIORITY_BACKGROUND);
thread.start();

mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
SO:
1.
创建一个线程，开始，取得Looper()，通过Looper创建Handler,并实现其hendlerMessage的方法

SEE:
1.
// We show this for as long as our service is processing a command.
notification.flags |= Notification.FLAG_ONGOING_EVENT;
SO:
当service在处理command的时候notification存在。


SEE:正常路线
1.
startService(new Intent(Controller.this,
ServiceStartArguments.class)
.putExtra("name", "One"));
2.
public int onStartCommand(Intent intent, int flags, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.arg2 = flags;
msg.obj = intent.getExtras();
mServiceHandler.sendMessage(msg);
3.
public void handleMessage(Message msg) {
Bundle arguments = (Bundle)msg.obj;

String txt = arguments.getString("name");

Log.i("ServiceStartArguments", "Message: " + msg + ", "
+ arguments.getString("name"));

if ((msg.arg2&Service.START_FLAG_REDELIVERY) == 0) {
txt = "New cmd #" + msg.arg1 + ": " + txt;
} else {
txt = "Re-delivered #" + msg.arg1 + ": " + txt;
}

showNotification(txt);
4.
long endTime = System.currentTimeMillis() + 5*1000;
while (System.currentTimeMillis() < endTime) {
synchronized (this) {
try {
wait(endTime - System.currentTimeMillis());
} catch (Exception e) {
}
}
}

hideNotification();

Log.i("ServiceStartArguments", "Done with #" + msg.arg1);
stopSelf(msg.arg1);
}
5.
public void onDestroy() {
mServiceLooper.quit();

hideNotification();

// Tell the user we stopped.
Toast.makeText(ServiceStartArguments.this, R.string.service_destroyed,
Toast.LENGTH_SHORT).show();
}

SO:
1.
启动SERVICE
2.
将启动时的状态，发送给HANDLER处理
3.
当flag为Service.START_FLAG_REDELIVERY的时候做不同的处理
4.
等待5秒，关掉NOTIFICATION.
5.
接下来继续处理其他的MESSAGE，所以每一个NOTIFICATION将持续五秒。直到所有的MESSAGE处理完了，调用HANDLER的onDestory方法，这是显示 service destory 的 toast


SEE:不正常路线 FAIL
1.
private OnClickListener mStartFailListener = new OnClickListener() {
public void onClick(View v) {
startService(new Intent(Controller.this,
ServiceStartArguments.class)
.putExtra("name", "Failure")
.putExtra("fail", true));
}
};
2.
// For the start fail button, we will simulate the process dying
// for some reason in onStartCommand().
if (intent.getBooleanExtra("fail", false)) {
// Don't do this if we are in a retry... the system will
// eventually give up if we keep crashing.
if ((flags&START_FLAG_RETRY) == 0) {
// Since the process hasn't finished handling the command,
// it will be restarted with the command again, regardless of
// whether we return START_REDELIVER_INTENT.
Process.killProcess(Process.myPid());
}
}
3.
点击 start failed delivery 并等待
SO:
1.
启动service
2.
第一次启动服务的时候，flag肯定不是START_FLAG_RETRY，所以killProcess。
3.
killProcess后 service自动重启。这时的FLAG为START_FLAG_RETRY 所以正常显示NOTIFICATION

SEE:不正常路线 redeliver
1.
startService(new Intent(Controller.this,
ServiceStartArguments.class)
.putExtra("name", "Three")
.putExtra("redeliver", true));
2.
return intent.getBooleanExtra("redeliver", false)
? START_REDELIVER_INTENT : START_NOT_STICKY;
3.
点击 start three 并观察
4.
再次点击 start three 在 service destoryed之前点击 kill Process，并观察
SO:
1.
设置相关配置，开始service
2.
返回 START_REDELIVER_INTENT 表示需要当service 意外终止时重新发送 intent
3.
没有意外终止，显示new command
4.
意外终止，显示re_delivered,表明，该SERVICE重启，并重新接受INTENT


[size=x-large]TextToSpeechActivity.java[/size]

SEE:
1.
mTts = new TextToSpeech(this,this // TextToSpeech.OnInitListener
);
2.
// Implements TextToSpeech.OnInitListener.
public void onInit(int status) {
if (status == TextToSpeech.SUCCESS) {
int result = mTts.setLanguage(Locale.US);
if (result == TextToSpeech.LANG_MISSING_DATA ||
result == TextToSpeech.LANG_NOT_SUPPORTED) {
Log.e(TAG, "Language is not available.");
} else {
mAgainButton.setEnabled(true);
}
} else {
Log.e(TAG, "Could not initialize TextToSpeech.");
}
}
3.
mTts.speak(hello,
TextToSpeech.QUEUE_FLUSH, // Drop all pending entries in the playback queue.
null);

SO:
1.创建实例
2.监听初始化
3.说话。。


[size=x-large]VoiceRecognition.java[/size]

无法测试。。


====================================APP完~ 好像解密游戏呀