我无法在绑定服务中使用messenger下载图像尽管在单独的进程中显示服务的android清单中
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="edu.vuum.mocca"
android:versionCode="1"
android:versionName="1.0" >
<uses-permission android:name="android.permission.INTERNET"></uses-permission>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-sdk
android:minSdkVersion="14"
android:targetSdkVersion="19" />
<supports-screens android:smallScreens="false" android:xlargeScreens="true" android:normalScreens="true" android:largeScreens="true"/>
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme"
android:uiOptions="splitActionBarWhenNarrow">
<activity
android:name="edu.vuum.mocca.DownloadActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<service android:name="edu.vuum.mocca.DownloadService" android:process=":my_process"/>
</application>
</manifest>
Dowloadservice处理程序调用dowloadmessageandRespond，它给出了android.os.networkonmainthreadexception
但是服务处理程序在单独的进程中运行，所以上面的执行不应该来？
如果我在单独的线程中执行dowloadmessageandRespond方法，那么程序运行正常，在dowloadmessageandRespond方法中注释。
package edu.vuum.mocca;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import android.app.Activity;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Base64;
import android.util.Log;
/**
* @class DownloadService
*
* @brief DownloadService receives an Intent containing a URL (which
* is a type of URI) and a Messenger. It downloads the file at
* the URL, stores it on the file system, then returns the path
* name to the caller using the supplied Messenger.
*
* The DownloadService class implements the CommandProcessor
* pattern and The Messenger is used as part of the Active
* Object pattern.
*/
public class DownloadService extends Service
{
/**
* Used for debugging.
*/
private final String TAG = getClass().getName();
private final static int LOG_OP = 1;
/**
* Looper associated with the HandlerThread.
*/
// private volatile Looper mServiceLooper;
/**
* Implementation a Messenger that encapsulates the RequestHandler
* used to handle request Messages sent from the
* UniqueIDGeneratorActivity.
*/
private final static String MESSAGE_URL = "course.examples.Services.Logging.MESSAGE";
final Messenger mMessengerImpl =
new Messenger(new ServiceHandler());
/**
* Factory method to make the desired Intent.
*/
public static Intent makeIntent(Context context
) {
// Create the Intent that's associated to the DownloadService
// class.
Intent intent = new Intent(context,
DownloadService.class);
return intent;
}
/**
* @class ServiceHandler
*
* @brief An inner class that inherits from Handler and uses its
* handleMessage() hook method to process Messages sent to
* it from onStartCommnand() that indicate which images to
* download.
*/
private final class ServiceHandler extends Handler {
/**
* A factory method that creates a Message to return to the
* DownloadActivity with the pathname of the downloaded image.
*/
private Message makeReplyMessage(String pathname){
Message message = Message.obtain();
// Return the result to indicate whether the download
// succeeded or failed.
message.arg1 = pathname == null
? Activity.RESULT_CANCELED
: Activity.RESULT_OK;
Bundle bundle = new Bundle();
// Pathname for the downloaded image.
bundle.putString("PATHNAME",
pathname);
message.setData(bundle);
return message;
}
/**
* A factory method that creates a Message that contains
* information on the image to download and how to stop the
* Service.
*/
/* private Message makeDownloadMessage(Intent intent,
int startId){
Message message = Message.obtain();
// Include Intent & startId in Message to indicate which URI
// to retrieve and which request is being stopped when
// download completes.
message.obj = intent;
message.arg1 = startId;
return message;
}*/
/**
* Retrieves the designated image and reply to the
* DownloadActivity via the Messenger .
*/
private void downloadImageAndReply(Message message) {
final Messenger messenger = message.replyTo;
final String url=message.getData().getString(MESSAGE_URL);
// Download the requested image.
//final String pathname;
// new Thread( new Runnable() {
// public void run(){
String pathname = downloadImage(DownloadService.this,url);
Log.d(TAG, "pathname----- after downloadImage()"+pathname);
sendPath(messenger, pathname);
// }
// }).start();
}
/**
* Send the pathname back to the DownloadActivity via the
* messenger.
*/
private void sendPath(Messenger messenger,
String pathname) {
// Call factory method to create Message.
Message message = makeReplyMessage(pathname);
try {
if (messenger == null)
Log.d(TAG, "replyMessenger is null");
else {
Log.d(TAG, "sending key" + pathname);
// Send pathname to back to the DownloadActivity.
messenger.send(message);
}
} catch (RemoteException e) {
Log.e(getClass().getName(),
"Exception while sending.",
e);
}
}
/**
* Create a file to store the result of a download.
*
* @param context
* @param url
* @return
* @throws IOException
*/
private File getTemporaryFile(final Context context,
final String url) throws IOException {
return context.getFileStreamPath(Base64.encodeToString(url.getBytes(),
Base64.NO_WRAP)
+ System.currentTimeMillis());
}
/**
* Copy the contents of an InputStream into an OutputStream.
*
* @param in
* @param out
* @return
* @throws IOException
*/
private int copy(final InputStream in,
final OutputStream out) throws IOException {
final int BUFFER_LENGTH = 1024;
final byte[] buffer = new byte[BUFFER_LENGTH];
int totalRead = 0;
int read = 0;
while ((read = in.read(buffer)) != -1) {
out.write(buffer, 0, read);
totalRead += read;
}
return totalRead;
}
/**
* Download the requested image and return the local file path.
*
* @param context
* @param url
* @return
*/
public String downloadImage(final Context context,
final String url) {
try {
final File file = getTemporaryFile(context, url);
Log.d(getClass().getName(), " downloading to " + file);
final InputStream in = (InputStream)
new URL(url).getContent();
final OutputStream out =
new FileOutputStream(file);
copy(in, out);
in.close();
out.close();
return file.getAbsolutePath();
} catch (Exception e) {
Log.e(getClass().getName(),
"Exception while downloading. Returning null.");
Log.e(getClass().getName(),
e.toString());
e.printStackTrace();
return null;
}
}
/**
* Hook method that retrieves an image from a remote server.
*/
public void handleMessage( Message message) {
// Download the designated image and reply to the
// DownloadActivity via the Messenger sent with the
// Intent.
switch (message.what) {
case LOG_OP:
Log.i(TAG, message.getData().getString(MESSAGE_URL));
downloadImageAndReply(message);
break;
default:
super.handleMessage(message);
}
}
}
/**
* Hook method called when DownloadService is first launched by
* the Android ActivityManager.
*/
/* public void onCreate() {
super.onCreate();
// Create and start a background HandlerThread since by
// default a Service runs in the UI Thread, which we don't
// want to block.
HandlerThread thread =
new HandlerThread("DownloadService");
thread.start();
// Get the HandlerThread's Looper and use it for our Handler.
mServiceLooper = thread.getLooper();
mServiceHandler =
new ServiceHandler(mServiceLooper);
}*/
/**
* Hook method called each time a Started Service is sent an
* Intent via startService().
*/
/* public int onStartCommand(Intent intent,
int flags,
int startId) {
// Create a Message that will be sent to ServiceHandler to
// retrieve animagebased on the URI in the Intent.
Message message =
mServiceHandler.makeDownloadMessage(intent,
startId);
// Send the Message to ServiceHandler to retrieve an image
// based on contents of the Intent.
mServiceHandler.sendMessage(message);
// Don't restart the DownloadService automatically if its
// process is killed while it's running.
return Service.START_NOT_STICKY;
}*/
@Override
public IBinder onBind(Intent intent) {
return mMessengerImpl.getBinder();
}
}
downloadactivity downloadimage方法当用户单击“下载图像”按钮使用DownloadService下载图像时调用
package edu.vuum.mocca;
import java.lang.ref.WeakReference;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.Toast;
/**
* @class DownloadActivity
*
* @brief A class that allows a user to download a bitmap image using
* a DownloadService.
*/
public class DownloadActivity extends Activity {
/**
* Used for debugging.
*/
private final String TAG = getClass().getName();
private final static int LOG_OP = 1;
private final static String MESSAGE_URL = "course.examples.Services.Logging.MESSAGE";
private boolean mIsBound;
/**
* User's selection of URL to download
*/
private EditText mUrlEditText;
/**
* Image that's been downloaded
*/
private ImageView mImageView;
/**
* Default URL.
*/
private String mDefaultUrl =
"http://www.dre.vanderbilt.edu/~schmidt/ka.png";
/**
* Display progress of download
*/
private ProgressDialog mProgressDialog;
/**
* Reference to the Messenger that's implemented in the
* UniqueIDGeneratorService.
*/
private Messenger mMessengerRef = null;
/**
* This ServiceConnection is used to receive a Messenger proxy
* after binding to the UniqueIDGeneratorService using bindService().
*/
private ServiceConnection mConnection = new ServiceConnection() {
/**
* Called after the UniqueIDGeneratorService is connected to
* convey the result returned from onBind().
*/
public void onServiceConnected(ComponentName className,
IBinder messenger) {
//Log.d(TAG, "ComponentName:" + className);
// Create a newq Messenger that encapsulates the
// returned IBinder object and store it for later use
// in mMessengerRef.
mMessengerRef = new Messenger(messenger);
mIsBound = true;
}
/**
* Called if the Service crashes and is no longer
* available. The ServiceConnection will remain bound,
* but the service will not respond to any requests.
*/
public void onServiceDisconnected(ComponentName className) {
mMessengerRef = null;
mIsBound = false;
}
};
/**
* Method that initializes the Activity when it is first created.
*
* @param savedInstanceState
* Activity's previously frozen state, if there was one.
*/
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
/**
* Sets the content view specified in the main.xml file.
*/
setContentView(R.layout.main);
/**
* Caches references to the EditText and ImageView objects in
* data members to optimize subsequent access.
*/
mUrlEditText = (EditText) findViewById(R.id.mUrlEditText);
mImageView = (ImageView) findViewById(R.id.mImageView);
}
/**
* Show a toast, notifying a user of an error when retrieving a
* bitmap.
*/
void showErrorToast(String errorString) {
Toast.makeText(this,
errorString,
Toast.LENGTH_LONG).show();
}
/**
* Display a downloaded bitmap image if it's non-null; otherwise,
* it reports an error via a Toast.
*
* @param image
* The bitmap image
*/
void displayImage(Bitmap image)
{
if (mImageView == null)
showErrorToast("Problem with Application,"
+ " please contact the Developer.");
else if (image != null)
mImageView.setImageBitmap(image);
else
showErrorToast("image is corrupted,"
+ " please check the requested URL.");
}
/**
* Called when a user clicks a button to reset an image to
* default.
*
* @param view
* The "Reset Image" button
*/
public void resetImage(View view) {
mImageView.setImageResource(R.drawable.default_image);
}
/**
* Called when a user clicks the Download Image button to download
* an image using the DownloadService
*
* @param view
* The "Download Image" button
*/
public void downloadImage(View view) {
// Obtain the requested URL from the user input.
if (mIsBound) {
String url = getUrlString();
Log.e(DownloadActivity.class.getSimpleName(),
"Downloading " + url);
hideKeyboard();
// Inform the user that the download is starting.
showDialog("downloading via startService()");
// Create a request Message that indicates the Service should
// send the reply back to ReplyHandler encapsulated by the
// Messenger.
Message msg = Message.obtain(null, LOG_OP);
Bundle bundle = new Bundle();
bundle.putString(MESSAGE_URL, url);
msg.setData(bundle);
// Message request = Message.obtain();
msg.replyTo = new Messenger(new DownloadHandler(this));
try {
if (mMessengerRef != null) {
Log.d(TAG, "sending message to service with url");
// Send the request Message to the
// UniqueIDGeneratorService.
mMessengerRef.send(msg);
}
} catch (RemoteException e) {
e.printStackTrace();
}
// Create an Intent to download an image in the background via
// a Service. The downloaded image is later diplayed in the
// UI Thread via the downloadHandler() method defined below.
// DownloadService.makeIntent(this, Uri.parse( getUrlString()));
}else{
Log.d(TAG, "service is not bounded restat again");
}
}
/**
* Hook method called by Android when this Activity becomes
* visible.
*/
@Override
protected void onStart() {
super.onStart();
Log.d(TAG, "onStart()");
Log.d(TAG, "calling bindService()");
if (mMessengerRef == null)
// Bind to the UniqueIDGeneratorService associated with this
// Intent.
bindService(DownloadService.makeIntent(this),
this.mConnection,
Context.BIND_AUTO_CREATE);
}
@Override
protected void onStop() {
super.onStop();
if (mIsBound)
unbindService(mConnection);
}
/**
* @class DownloadHandler
*
* @brief An inner class that inherits from Handler and uses its
* handleMessage() hook method to process Messages sent to
* it from the DownloadService.
*/
private static class DownloadHandler extends Handler {
/**
* Allows Activity to be garbage collected properly.
*/
private WeakReference<DownloadActivity> mActivity;
/**
* Class constructor constructs mActivity as weak reference
* to the activity
*
* @param activity
* The corresponding activity
*/
public DownloadHandler(DownloadActivity activity) {
mActivity = new WeakReference<DownloadActivity>(activity);
}
/**
/**
* This hook method is dispatched in response to receiving
* the pathname back from the DownloadService.
*/
public void handleMessage(Message msg) {
DownloadActivity activity = mActivity.get();
// Bail out of the DownloadActivity is gone.
if (activity == null)
return;
// Extract the data from Message, which is in the form
// of a Bundle that can be passed across processes.
Bundle data = msg.getData();
// Extract the pathname from the Bundle.
String pathname = data.getString("PATHNAME");
// See if things worked or not.
if (msg.arg1 != RESULT_OK || pathname == null)
activity.showDialog("failed download");
// Stop displaying the progress dialog.
activity.dismissDialog();
// Display the image in the UI Thread.
activity.displayImage(BitmapFactory.decodeFile(pathname));
}
};
/**
* Display the Dialog to the User.
*
* @param message
* The String to display what download method was used.
*/
public void showDialog(String message) {
mProgressDialog =
ProgressDialog.show(this,
"Download",
message,
true);
}
/**
* Dismiss the Dialog
*/
public void dismissDialog() {
if (mProgressDialog != null)
mProgressDialog.dismiss();
}
/**
* Hide the keyboard after a user has finished typing the url.
*/
private void hideKeyboard() {
InputMethodManager mgr =
(InputMethodManager) getSystemService
(Context.INPUT_METHOD_SERVICE);
mgr.hideSoftInputFromWindow(mUrlEditText.getWindowToken(),
0);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.download, menu);
return true;
}
/**
* Read the URL EditText and return the String it contains.
*
* @return String value in mUrlEditText
*/
String getUrlString() {
String s = mUrlEditText.getText().toString();
if (s.equals(""))
s = mDefaultUrl;
return s;
}
}
使用messenger绑定服务，如果它在单独的进程中运行，则不需要单独的线程来执行长时间运行的任务。
我需要知道为什么这个downloadimage服务即使在单独的进程中运行也无法正常工作。
感谢您的帮助。
答案 0 :(得分：0)
由于存在NetworkOnMainThreadException，解决方案是将网络代码放在AsyncTask或thread中。