फ़ाइलों को डाउनलोड करने के कई तरीके हैं। निम्नलिखित मैं सबसे सामान्य तरीके पोस्ट करूंगा; यह आपको तय करना है कि आपके ऐप के लिए कौन सा तरीका बेहतर है।
1. AsyncTaskएक डायलॉग में डाउनलोड की प्रगति का उपयोग करें और दिखाएं
यह विधि आपको कुछ पृष्ठभूमि प्रक्रियाओं को निष्पादित करने और एक ही समय में यूआई को अपडेट करने की अनुमति देगा (इस मामले में, हम एक प्रगति बार अपडेट करेंगे)।
आयात:
import android.os.PowerManager;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FileOutputStream;
import java.net.HttpURLConnection;
यह एक उदाहरण कोड है:
// declare the dialog as a member field of your activity
ProgressDialog mProgressDialog;
// instantiate it within the onCreate method
mProgressDialog = new ProgressDialog(YourActivity.this);
mProgressDialog.setMessage("A message");
mProgressDialog.setIndeterminate(true);
mProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
mProgressDialog.setCancelable(true);
// execute this when the downloader must be fired
final DownloadTask downloadTask = new DownloadTask(YourActivity.this);
downloadTask.execute("the url to the file you want to download");
mProgressDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
@Override
public void onCancel(DialogInterface dialog) {
downloadTask.cancel(true); //cancel the task
}
});
इस AsyncTaskतरह दिखेगा:
// usually, subclasses of AsyncTask are declared inside the activity class.
// that way, you can easily modify the UI thread from here
private class DownloadTask extends AsyncTask<String, Integer, String> {
private Context context;
private PowerManager.WakeLock mWakeLock;
public DownloadTask(Context context) {
this.context = context;
}
@Override
protected String doInBackground(String... sUrl) {
InputStream input = null;
OutputStream output = null;
HttpURLConnection connection = null;
try {
URL url = new URL(sUrl[0]);
connection = (HttpURLConnection) url.openConnection();
connection.connect();
// expect HTTP 200 OK, so we don't mistakenly save error report
// instead of the file
if (connection.getResponseCode() != HttpURLConnection.HTTP_OK) {
return "Server returned HTTP " + connection.getResponseCode()
+ " " + connection.getResponseMessage();
}
// this will be useful to display download percentage
// might be -1: server did not report the length
int fileLength = connection.getContentLength();
// download the file
input = connection.getInputStream();
output = new FileOutputStream("/sdcard/file_name.extension");
byte data[] = new byte[4096];
long total = 0;
int count;
while ((count = input.read(data)) != -1) {
// allow canceling with back button
if (isCancelled()) {
input.close();
return null;
}
total += count;
// publishing the progress....
if (fileLength > 0) // only if total length is known
publishProgress((int) (total * 100 / fileLength));
output.write(data, 0, count);
}
} catch (Exception e) {
return e.toString();
} finally {
try {
if (output != null)
output.close();
if (input != null)
input.close();
} catch (IOException ignored) {
}
if (connection != null)
connection.disconnect();
}
return null;
}
उपरोक्त विधि ( doInBackground) हमेशा पृष्ठभूमि थ्रेड पर चलती है। आपको कोई UI कार्य नहीं करना चाहिए। दूसरी ओर, onProgressUpdateऔर onPreExecuteUI थ्रेड पर चलते हैं, इसलिए वहां आप प्रगति बार को बदल सकते हैं:
@Override
protected void onPreExecute() {
super.onPreExecute();
// take CPU lock to prevent CPU from going off if the user
// presses the power button during download
PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
getClass().getName());
mWakeLock.acquire();
mProgressDialog.show();
}
@Override
protected void onProgressUpdate(Integer... progress) {
super.onProgressUpdate(progress);
// if we get here, length is known, now set indeterminate to false
mProgressDialog.setIndeterminate(false);
mProgressDialog.setMax(100);
mProgressDialog.setProgress(progress[0]);
}
@Override
protected void onPostExecute(String result) {
mWakeLock.release();
mProgressDialog.dismiss();
if (result != null)
Toast.makeText(context,"Download error: "+result, Toast.LENGTH_LONG).show();
else
Toast.makeText(context,"File downloaded", Toast.LENGTH_SHORT).show();
}
इसे चलाने के लिए, आपको WAKE_LOCK की अनुमति चाहिए।
<uses-permission android:name="android.permission.WAKE_LOCK" />
2. डाउनलोड सेवा
यहां बड़ा सवाल यह है कि मैं अपनी गतिविधि को सेवा से कैसे अपडेट करूं? । अगले उदाहरण में हम दो वर्गों का उपयोग करने जा रहे हैं जिनके बारे में आप शायद नहीं जानते होंगे: ResultReceiverऔर IntentService। ResultReceiverवह है जो हमें एक सेवा से हमारे थ्रेड को अपडेट करने की अनुमति देगा; IntentServiceएक उपवर्ग है, Serviceजो वहां से पृष्ठभूमि का काम करने के लिए एक धागा पैदा करता है (आपको पता होना चाहिए कि Serviceवास्तव में आपके ऐप के उसी धागे में एक रन है; जब आप विस्तार करते हैं Service, तो आपको सीपीयू अवरुद्ध संचालन को चलाने के लिए मैन्युअल रूप से नए थ्रेड स्पॉन करना होगा)।
डाउनलोड सेवा इस तरह देख सकते हैं:
public class DownloadService extends IntentService {
public static final int UPDATE_PROGRESS = 8344;
public DownloadService() {
super("DownloadService");
}
@Override
protected void onHandleIntent(Intent intent) {
String urlToDownload = intent.getStringExtra("url");
ResultReceiver receiver = (ResultReceiver) intent.getParcelableExtra("receiver");
try {
//create url and connect
URL url = new URL(urlToDownload);
URLConnection connection = url.openConnection();
connection.connect();
// this will be useful so that you can show a typical 0-100% progress bar
int fileLength = connection.getContentLength();
// download the file
InputStream input = new BufferedInputStream(connection.getInputStream());
String path = "/sdcard/BarcodeScanner-debug.apk" ;
OutputStream output = new FileOutputStream(path);
byte data[] = new byte[1024];
long total = 0;
int count;
while ((count = input.read(data)) != -1) {
total += count;
// publishing the progress....
Bundle resultData = new Bundle();
resultData.putInt("progress" ,(int) (total * 100 / fileLength));
receiver.send(UPDATE_PROGRESS, resultData);
output.write(data, 0, count);
}
// close streams
output.flush();
output.close();
input.close();
} catch (IOException e) {
e.printStackTrace();
}
Bundle resultData = new Bundle();
resultData.putInt("progress" ,100);
receiver.send(UPDATE_PROGRESS, resultData);
}
}
अपने मेनिफेस्ट में सेवा जोड़ें:
<service android:name=".DownloadService"/>
और गतिविधि इस तरह दिखाई देगी:
// initialize the progress dialog like in the first example
// this is how you fire the downloader
mProgressDialog.show();
Intent intent = new Intent(this, DownloadService.class);
intent.putExtra("url", "url of the file to download");
intent.putExtra("receiver", new DownloadReceiver(new Handler()));
startService(intent);
यहाँ ResultReceiverखेलने के लिए आता है:
private class DownloadReceiver extends ResultReceiver{
public DownloadReceiver(Handler handler) {
super(handler);
}
@Override
protected void onReceiveResult(int resultCode, Bundle resultData) {
super.onReceiveResult(resultCode, resultData);
if (resultCode == DownloadService.UPDATE_PROGRESS) {
int progress = resultData.getInt("progress"); //get the progress
dialog.setProgress(progress);
if (progress == 100) {
dialog.dismiss();
}
}
}
}
2.1 ग्राउंडी लाइब्रेरी का उपयोग करें
ग्राउंडी एक पुस्तकालय है जो मूल रूप से आपको पृष्ठभूमि सेवा में कोड के टुकड़े चलाने में मदद करता है, और यहResultReceiverऊपर दिखाए गए अवधारणापर आधारितहै। इस लाइब्रेरी कोफिलहाल हटा दिया गया है। इसतरह पूरा कोड दिखेगा:
गतिविधि जहां आप संवाद दिखा रहे हैं ...
public class MainActivity extends Activity {
private ProgressDialog mProgressDialog;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
findViewById(R.id.btn_download).setOnClickListener(new View.OnClickListener() {
public void onClick(View view) {
String url = ((EditText) findViewById(R.id.edit_url)).getText().toString().trim();
Bundle extras = new Bundler().add(DownloadTask.PARAM_URL, url).build();
Groundy.create(DownloadExample.this, DownloadTask.class)
.receiver(mReceiver)
.params(extras)
.queue();
mProgressDialog = new ProgressDialog(MainActivity.this);
mProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
mProgressDialog.setCancelable(false);
mProgressDialog.show();
}
});
}
private ResultReceiver mReceiver = new ResultReceiver(new Handler()) {
@Override
protected void onReceiveResult(int resultCode, Bundle resultData) {
super.onReceiveResult(resultCode, resultData);
switch (resultCode) {
case Groundy.STATUS_PROGRESS:
mProgressDialog.setProgress(resultData.getInt(Groundy.KEY_PROGRESS));
break;
case Groundy.STATUS_FINISHED:
Toast.makeText(DownloadExample.this, R.string.file_downloaded, Toast.LENGTH_LONG);
mProgressDialog.dismiss();
break;
case Groundy.STATUS_ERROR:
Toast.makeText(DownloadExample.this, resultData.getString(Groundy.KEY_ERROR), Toast.LENGTH_LONG).show();
mProgressDialog.dismiss();
break;
}
}
};
}
एक GroundyTaskकार्यान्वयन के द्वारा प्रयोग किया Groundy फ़ाइल डाउनलोड करने और प्रगति दिखाने के लिए:
public class DownloadTask extends GroundyTask {
public static final String PARAM_URL = "com.groundy.sample.param.url";
@Override
protected boolean doInBackground() {
try {
String url = getParameters().getString(PARAM_URL);
File dest = new File(getContext().getFilesDir(), new File(url).getName());
DownloadUtils.downloadFile(getContext(), url, dest, DownloadUtils.getDownloadListenerForTask(this));
return true;
} catch (Exception pokemon) {
return false;
}
}
}
और इसे प्रकट में जोड़ें:
<service android:name="com.codeslap.groundy.GroundyService"/>
मुझे लगता है कि यह आसान नहीं हो सकता। बस जीथब से नवीनतम जार पकड़ो और आप जाने के लिए तैयार हैं। ध्यान रखें कि ग्राउंडी का मुख्य उद्देश्य पृष्ठभूमि सेवा में बाहरी REST एपिस को कॉल करना और परिणाम को आसानी से UI पर पोस्ट करना है। यदि आप अपने ऐप में ऐसा कुछ कर रहे हैं, तो यह वास्तव में उपयोगी हो सकता है।
3. DownloadManagerकक्षा का उपयोग करें ( GingerBreadऔर केवल नया)
जिंजरब्रेड एक नई सुविधा लाया DownloadManager, जो आपको आसानी से फ़ाइलों को डाउनलोड करने और सिस्टम को थ्रेड्स, स्ट्रीम इत्यादि को संभालने के कठिन काम को सौंपने की अनुमति देता है।
सबसे पहले, आइए एक उपयोगिता विधि देखें:
/**
* @param context used to check the device version and DownloadManager information
* @return true if the download manager is available
*/
public static boolean isDownloadManagerAvailable(Context context) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
return true;
}
return false;
}
विधि का नाम यह सब समझाता है। एक बार जब आप सुनिश्चित हैं कि DownloadManagerउपलब्ध है, आप कुछ इस तरह से कर सकते हैं:
String url = "url you want to download";
DownloadManager.Request request = new DownloadManager.Request(Uri.parse(url));
request.setDescription("Some descrition");
request.setTitle("Some title");
// in order for this if to run, you must use the android 3.2 to compile your app
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
request.allowScanningByMediaScanner();
request.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED);
}
request.setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, "name-of-the-file.ext");
// get download service and enqueue file
DownloadManager manager = (DownloadManager) getSystemService(Context.DOWNLOAD_SERVICE);
manager.enqueue(request);
सूचना पट्टी में डाउनलोड प्रगति दिखाई देगी।
अंतिम विचार
पहले और दूसरे तरीके सिर्फ हिमशैल के टिप हैं। अगर आप चाहते हैं कि आपका ऐप मजबूत हो, तो बहुत सारी बातें आपको ध्यान में रखनी होंगी। यहाँ एक संक्षिप्त सूची है:
- आपको यह देखना होगा कि उपयोगकर्ता के पास इंटरनेट कनेक्शन उपलब्ध है या नहीं
- सुनिश्चित करें कि आपके पास सही अनुमति (
INTERNETऔर WRITE_EXTERNAL_STORAGE) है; भी ACCESS_NETWORK_STATEआप इंटरनेट उपलब्धता देखने के लिए चाहते हैं।
- सुनिश्चित करें कि आप जिस निर्देशिका को डाउनलोड करने जा रहे हैं, वह फाइल मौजूद है और लिखने की अनुमति है।
- यदि डाउनलोड बहुत बड़ा है, तो आप पिछले प्रयासों के विफल होने पर डाउनलोड को फिर से शुरू करने का तरीका लागू कर सकते हैं।
- यदि आप उन्हें डाउनलोड को बाधित करने की अनुमति देते हैं तो उपयोगकर्ता आभारी होंगे।
जब तक आपको डाउनलोड प्रक्रिया के विस्तृत नियंत्रण की आवश्यकता न हो, तब DownloadManager(3) का उपयोग करने पर विचार करें क्योंकि यह पहले से ही ऊपर सूचीबद्ध अधिकांश वस्तुओं को संभालता है।
लेकिन यह भी विचार करें कि आपकी ज़रूरतें बदल सकती हैं। उदाहरण के लिए, DownloadManager कोई प्रतिक्रिया कैशिंग नहीं है । यह नेत्रहीन एक ही बड़ी फ़ाइल को कई बार डाउनलोड करेगा। इस तथ्य के बाद इसे ठीक करने का कोई आसान तरीका नहीं है। जहां यदि आप एक मूल HttpURLConnection(1, 2) से शुरू करते हैं , तो आपको केवल एक जोड़ने की जरूरत है HttpResponseCache। तो बुनियादी, मानक उपकरण सीखने का प्रारंभिक प्रयास एक अच्छा निवेश हो सकता है।
इस वर्ग को एपीआई स्तर 26 में पदावनत किया गया था। प्रोग्रेसडायलॉग एक मोडल संवाद है, जो उपयोगकर्ता को ऐप के साथ बातचीत करने से रोकता है। इस वर्ग का उपयोग करने के बजाय, आपको प्रगति सूचक जैसे प्रगति संकेतक का उपयोग करना चाहिए, जिसे आपके ऐप के यूआई में एम्बेड किया जा सकता है। वैकल्पिक रूप से, आप कार्य की प्रगति के उपयोगकर्ता को सूचित करने के लिए एक अधिसूचना का उपयोग कर सकते हैं। अधिक जानकारी के लिए लिंक