'Android.os.NetworkOnMainThreadException' නිවැරදි කරන්නේ කෙසේද?


2403

RssReader සඳහා මගේ ඇන්ඩ්‍රොයිඩ් ව්‍යාපෘතිය ක්‍රියාත්මක කිරීමේදී මට දෝෂයක් ඇතිවිය.

කේතය:

URL url = new URL(urlToRssFeed);
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser parser = factory.newSAXParser();
XMLReader xmlreader = parser.getXMLReader();
RssHandler theRSSHandler = new RssHandler();
xmlreader.setContentHandler(theRSSHandler);
InputSource is = new InputSource(url.openStream());
xmlreader.parse(is);
return theRSSHandler.getFeed();

එය පහත දෝෂය පෙන්වයි:

android.os.NetworkOnMainThreadException

මෙම ගැටළුව විසඳන්නේ කෙසේද?


131
වැඩි විස්තර සඳහා NetworkOnMainThreadException හි මෙම බ්ලොග් සටහන කියවන්න . ඇන්ඩ්‍රොයිඩ් 3.0 සහ ඊට ඉහළින් මෙය සිදුවන්නේ මන්දැයි එය පැහැදිලි කරයි.
ඒඩ්‍රියන් මොන්ක්

6
චාරිත්රානුකූලව ගමන් කිරීම සඳහා ප්රථමයෙන් ඇන්ඩ්රොයිඩ් හි ජාල ඉල්ලීම් ගැන කියවා පසුව "වොලී" අධ්යයනය කිරීමට මම නිර්දේශ කරමි.
අනුජ් ෂර්මා

3
මෙම ගැටළුව විසඳන විකල්ප පුස්තකාල බොහොමයක් තිබේ. බොහෝමයක් මෙම පිටුවේ පහතින් ලැයිස්තුගත කර ඇත . ඔබට තවත් ලැබුනේ නම්, අපි ඒවා රැගෙන
යන්නෙමු

ප්‍රධාන (යූඅයි) නූලෙන් වෙන් වූ ත්‍රෙඩ් එකකින් ඔබට අන්තර්ජාල ක්‍රියාකාරකම් ක්‍රියාත්මක කළ යුතුය
නවීඩ් අහමඩ්

"ඇන්ඩ්‍රොයිඩ් හි පෙර සංස්කරණවල ඇති වූ දෝෂයක් හේතුවෙන්, පද්ධතිය ප්‍රධාන මාදිලියේ ටීසීපී සොකට්ටුවකට ලිවීම දැඩි මාදිලියේ උල්ලං as නය කිරීමක් ලෙස සලකුණු නොකළේය. ඇන්ඩ්‍රොයිඩ් 7.0 මෙම දෝෂය නිරාකරණය කරයි. මෙම හැසිරීම ප්‍රදර්ශනය කරන යෙදුම් දැන් android.os විසි කරයි. NetworkOnMainThreadException. " - ඉතින් අපෙන් සමහරු මෑතක් වන තුරුම මෙය වැසුවේ නැත! developer.android.com/about/versions/nougat/...
ජේ

Answers:


2554

යෙදුමක් එහි ප්‍රධාන නූලෙන් ජාලකරණ මෙහෙයුමක් කිරීමට උත්සාහ කරන විට මෙම ව්‍යතිරේකය විසි වේ. ඔබේ කේතය ක්‍රියාත්මක කරන්න AsyncTask:

class RetrieveFeedTask extends AsyncTask<String, Void, RSSFeed> {

    private Exception exception;

    protected RSSFeed doInBackground(String... urls) {
        try {
            URL url = new URL(urls[0]);
            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser parser = factory.newSAXParser();
            XMLReader xmlreader = parser.getXMLReader();
            RssHandler theRSSHandler = new RssHandler();
            xmlreader.setContentHandler(theRSSHandler);
            InputSource is = new InputSource(url.openStream());
            xmlreader.parse(is);

            return theRSSHandler.getFeed();
        } catch (Exception e) {
            this.exception = e;

            return null;
        } finally {
            is.close();
        }
    }

    protected void onPostExecute(RSSFeed feed) {
        // TODO: check this.exception
        // TODO: do something with the feed
    }
}

කාර්යය ඉටු කරන්නේ කෙසේද:

දී MainActivity.javaඇති ගොනුවේ ඔබ තුළ මෙම මාර්ගය එකතු කළ හැකි oncreate()ක්රමය

new RetrieveFeedTask().execute(urlToRssFeed);

මෙය AndroidManifest.xmlගොනුවට එක් කිරීමට අමතක නොකරන්න :

<uses-permission android:name="android.permission.INTERNET"/>

37
ඉහත කේත ස්නිපටය උප පංතියක් (අභ්‍යන්තර පංතියක්) විය යුතු බව මෙහිදී සඳහන් කිරීම වටී යැයි මම සිතමි. AsyncTask අවසන් වූ විට, ඔබට තවමත් ඔබේ පන්තියේ අභ්‍යන්තරය හැසිරවිය හැකිය.
dyslexicanaboko

4
ඇත්තටම මට ඔබ ඉහත සඳහන් කළ පරිදි ම කෙළේ නමුත් මෙම දෝෂය මුහුණ මීටර් Looper.prepare (called කර නැති බව නූල් ඇතුළත හැසිරවීම නිර්මාණය කල නොහැක): java.lang.RuntimeException
Dhruv Tyagi

69
මෙය හරියටම වැරදි පිළිතුරයි. මම මෙය සැමවිටම මහජන කේතයෙන් හමු වන අතර එය නිතරම නිවැරදි කිරීමට සිදුවීම කරදරයකි. ජාල ක්‍රියාකාරකම් සඳහා AsyncTask භාවිතා නොකළ යුතුය, මන්ද එය ක්‍රියාකාරකමට බැඳී ඇති නමුත් ක්‍රියාකාරකම් ජීවන චක්‍රය නොවේ. මෙම කාර්යය සමඟ උපාංගය භ්‍රමණය වීම ව්‍යතිරේකයක් ඇති කර ඔබගේ යෙදුම බිඳ වැටෙනු ඇත. ඒ වෙනුවට sqlite දත්ත ගබඩාවේ දත්ත පහත වැටෙන IntentService එකක් භාවිතා කරන්න.
බ්‍රිල් පැපින්

5
අවවාදයයි, AsyncTask බොහෝ විට එක් ක්‍රියාකාරකම් ජාල මෙහෙයුම් සඳහා භාවිතා නොකළ යුතුය. එහි ජීවන චක්‍රය ක්‍රියාකාරකම සමඟ සමපාත නොවේ. දත්ත ලබා ගැනීම සඳහා, ඔබ දර්ශනය පිටුපස ඇති IntentService සහ දත්ත සමුදාය භාවිතා කළ යුතුය.
බ්‍රිල් පැපින්

1
AndroidBrillPappin, FWIW, මෙම ඇන්ඩ්‍රොයිඩ් සංවර්ධක මාර්ගෝපදේශය භාවිතා AsyncTaskකරන අතර වින්‍යාස වෙනස් කිරීමක් ගැන සැලකිලිමත් වේ.
හේයිජුඩ්

680

ඔබ සෑම විටම පාහේ ජාල මෙහෙයුම් නූල් මත හෝ අසමමුහුර්ත කාර්යයක් ලෙස ක්‍රියාත්මක කළ යුතුය.

නමුත් එය වේ මෙම සීමා කිරීම ඉවත් කිරීමට සහ ඔබ ප්රතිවිපාක පිළිගන්න කැමැති නම්, ඔබ, සැකසුම් හැසිරීම යටපත් කිරීම හැකි.

එකතු කරන්න:

StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();

StrictMode.setThreadPolicy(policy); 

ඔබේ පන්තියේදී,

සහ

Android මැනිෆෙස්ට්. Xml ගොනුවේ මෙම අවසරය එක් කරන්න:    

<uses-permission android:name="android.permission.INTERNET"/>

ප්‍රතිවිපාක:

ඔබගේ යෙදුම (ස්ථානීය අන්තර්ජාල සම්බන්ධතා ඇති ප්‍රදේශවල) ප්‍රතිචාර නොදක්වන අතර අගුලු දමනු ඇත, පරිශීලකයා මන්දගාමී බව වටහාගෙන බලහත්කාරයෙන් kill ාතනය කළ යුතු අතර, ක්‍රියාකාරකම් කළමනාකරු ඔබේ යෙදුම මරා දමා යෙදුම නතර වී ඇති බව පරිශීලකයාට පවසනු ඇත.

ප්‍රතිචාර දැක්වීම සඳහා සැලසුම් කිරීම සඳහා ඇන්ඩ්‍රොයිඩ් සතුව හොඳ ක්‍රමලේඛන භාවිතයන් පිළිබඳ හොඳ උපදෙස් කිහිපයක් තිබේ: http://developer.android.com/reference/android/os/NetworkOnMainThreadException.html


456
මෙය ඉතා නරක අදහසකි. විසඳුම වන්නේ ප්‍රධාන නූල් මත ජාල IO වළක්වා ගැනීමයි (පිළිගත් පිළිතුර පෙන්වන පරිදි).
MByD

74
මේ සමඟ ඔබ සැඟවී සිටින්නේ ඔබේ සැබෑ ගැටලුව පමණි.
ඇලෙක්ස්

28
WTwistedUmbrella AsyncTask කේතයේ පිටුවක් එක් නොකරයි, එය පේළි 6 ක් එක් කරයි (පන්ති ප්‍රකාශනය, විවරණය ඉක්මවා යාම, doInBackgroundප්‍රකාශනය, සංවෘත වරහන් 2 ක් සහ ඇමතුමක් execute()). අනෙක් අතට, ඔබ සඳහන් කළ පරිදි වෙබ් අඩවියකින් එක් ලබා ගැනීමක් පවා UI ප්‍රතිචාර දැක්වීමේ සැලකිය යුතු පසුබෑමක් ගෙන එයි. කම්මැලි නොවන්න.
සොල්ටන්

19
නිසි AsyncTask ක්‍රියාත්මක කිරීමට පෙර යමක් ක්‍රියාත්මක වේදැයි බැලීමට ඔබ නියැදි කේත කැබැල්ලක් ධාවනය කිරීමට බලාපොරොත්තු වන්නේ නම් මෙය හොඳම විසඳුම යැයි මම සිතමි. අනෙක් අය පවසා ඇති පරිදි මෙය නිෂ්පාදන යෙදුමක නොකළ යුතු අතර එය dev පරීක්ෂණයකට ඉක්මන් විසඳුමක් ලෙස පමණක් මම මෙම පිළිතුර ඉදිරිපත් කළෙමි.
කොක්ක 82

95
ඉහළට. මෙම පිළිතුර නිවැරදියි, බොළඳ හෝ මෝඩ නොවන, නමුත් සරලවම සින්ක්‍රෝනස් (එනම්: මෙය යෙදුම අවහිර කළ යුතුය ) ඇමතුමක් අවශ්‍ය බොහෝ ක්‍රමලේඛකයින් සඳහා , මෙය හරියටම අවශ්‍ය වේ. ඇන්ඩ්‍රොයිඩ් පෙරනිමියෙන් ව්‍යතිරේකය විසි කිරීම ගැන මම සතුටු වෙමි (IMHO එය ඉතා “ප්‍රයෝජනවත්” දෙයක්!) - නමුත් “ස්තූතියි, නමුත් - මෙය ඇත්ත වශයෙන්ම මා අදහස් කළේ එයයි” සහ ඉක්මවා යාම ගැන මම එකසේ සතුටු වෙමි. එය.
ආදම්

428

මම මෙම ගැටළුව නව එකක් භාවිතයෙන් විසඳුවා Thread.

Thread thread = new Thread(new Runnable() {

    @Override
    public void run() {
        try  {
            //Your code goes here
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
});

thread.start(); 

7
ඔබට ජාල මෙහෙයුමක් කිරීමට අවශ්‍ය සෑම අවස්ථාවකම නව නූලක් නිර්මාණය කරනවා වෙනුවට, ඔබට තනි නූල් ක්‍රියාත්මක කිරීමේ සේවාවක් ද භාවිතා කළ හැකිය.
ඇලෙක්ස් ලොක්වුඩ්

66
සරල නමුත් භයානක ය. නිර්නාමික ධාවන පථයට කොටු කිරීමේ පන්තියට (උදා: ඔබේ ක්‍රියාකාරකම හෝ කැබැල්ල) ව්‍යංග යොමු කිරීමක් ඇත, එය නූල් සම්පුර්ණ වන තෙක් කසළ එකතු වීම වළක්වයි. ඔබ අවම වශයෙන් Process.BACKGROUND වෙත ප්‍රමුඛතාවය නියම කළ යුතුය, එසේ නොමැතිනම් මෙම නූල් ප්‍රධාන / ui නූල් මෙන් ක්‍රියා කරයි, ජීවන චක්‍ර ක්‍රම සහ ui රාමු අනුපාත සමඟ තරඟ කරයි (නර්තන ශිල්පියාගේ ලොග් අනතුරු ඇඟවීම් ගැන විමසිල්ලෙන් සිටින්න).
ස්ටීවි

1
ප්‍රමුඛතාවය සකසන්නේ කෙසේද? ක්‍රියාත්මක කළ හැකි හෝ ක්‍රියාත්මක කරන සේවයට එවැනි සැකසුම් ක්‍රමයක් නොමැත
ජේකේ

1
@JK ඔබේ ක්‍රියාත්මක කරන්නාගේ සේවාව අභිරුචි ThreadFactory එකකින් ලබා දී එය නැවත ලබා දීමට පෙර Thread.setPriority අමතන්න.
ස්ටීවි

1
"ඇන්ඩ්‍රොයිඩ් හි කෙලින්ම නූල් භාවිතා කිරීම අධෛර්යමත් කර ඇත. එය විසඳීමට වඩා ගැටලු ඇති කරයි" ඒ ගැන විස්තර කිරීමට සැලකිලිමත්ද? ඇත්ත වශයෙන්ම ඒ සඳහා අසින්ක් ටාස්ක් ඉවත් කරනු ලැබේ ... techyourchance.com/asynctask-deprecated
Fran Marzoa

170

පිළිගත් පිළිතුරට සැලකිය යුතු පහළ පැත්තක් ඇත. ඔබ කරන්නේ කුමක්දැයි ඔබ සැබවින්ම නොදන්නේ නම් ජාලගත කිරීම සඳහා AsyncTask භාවිතා කිරීම සුදුසු නොවේ . සමහර පහළ පැතිවලට ඇතුළත් වන්නේ:

  • ස්ථිතික නොවන අභ්‍යන්තර පංති ලෙස නිර්මාණය කරන ලද AsyncTask හි ක්‍රියාකාරී වස්තුව, එහි සන්දර්භය සහ එම ක්‍රියාකාරකම විසින් නිර්මාණය කරන ලද සමස්ත දර්ශන ධූරාවලිය පිළිබඳව ව්‍යංග සඳහනක් ඇත. මෙම සඳහන AsyncTask හි පසුබිම් කටයුතු අවසන් වන තුරු ක්‍රියාකාරකම් කසළ එකතු වීම වළක්වයි. පරිශීලකයාගේ සම්බන්ධතාවය මන්දගාමී නම් සහ / හෝ බාගැනීම විශාල නම්, මෙම කෙටිකාලීන මතක කාන්දු වීම ගැටලුවක් බවට පත්විය හැකිය - නිදසුනක් ලෙස, දිශානතිය කිහිප වතාවක් වෙනස් වුවහොත් (සහ ඔබ ක්‍රියාත්මක කිරීමේ කාර්යයන් අවලංගු නොකරයි), හෝ පරිශීලකයා ක්‍රියාකාරකමෙන් away ත් වේ.
  • අසින්ක් ටාස්ක් එය ක්‍රියාත්මක කරන වේදිකාව අනුව වෙනස් ක්‍රියාත්මක කිරීමේ ලක්ෂණ ඇත: ඒපීඅයි මට්ටම 4 ට පෙර අසින්ක් ටාස්ක්ස් තනි පසුබිම් නූලක් මත අනුක්‍රමිකව ක්‍රියාත්මක කරයි; API මට්ටම 4 සිට API මට්ටම 10 දක්වා, අසින්ක් ටාස්ක් නූල් 128 ක් දක්වා වූ තටාකයක් මත ක්‍රියාත්මක කරයි; API මට්ටමේ 11 සිට AsyncTask තනි පසුබිම් නූලක් මත අනුක්‍රමිකව ක්‍රියාත්මක කරයි (ඔබ අධික ලෙස පටවන ලද executeOnExecutorක්‍රමය භාවිතා කර විකල්ප ක්‍රියාත්මක කරන්නෙකු සපයන්නේ නැත්නම් ). ජින්ජර් බ්‍රෙඩ් සමඟ සමගාමීව ක්‍රියාත්මක වන විට ICS හි අනුක්‍රමිකව ක්‍රියාත්මක වන විට හොඳින් ක්‍රියාත්මක වන කේතය කැඩී යා හැක, ඔබට නොදැනුවත්වම ක්‍රියාත්මක කිරීමේ පරායත්තතා තිබේ නම් කියන්න.

ඔබට කෙටිකාලීන මතක කාන්දුවීම් වළක්වා ගැනීමට අවශ්‍ය නම්, සියලු වේදිකා හරහා මනාව නිර්වචනය කර ඇති ක්‍රියාත්මක කිරීමේ ලක්ෂණ සහ සැබවින්ම ශක්තිමත් ජාල හැසිරවීමක් ගොඩනැගීමට පදනමක් තිබේ නම්, ඔබට සලකා බැලිය යුතුය:

  1. ඔබ වෙනුවෙන් මේ සඳහා හොඳ කාර්යයක් කරන පුස්තකාලයක් භාවිතා කිරීම - මෙම ප්‍රශ්නයේ ජාලකරණ ලිබ් සමඟ සැසඳීමක් තිබේ , හෝ
  2. ක්‍රියාකාරකම් ක්‍රමය හරහා ප්‍රති result ලය ලබා දීමට a Serviceහෝ IntentServiceඒ වෙනුවට භාවිතා කිරීම .PendingIntentonActivityResult

අභිප්‍රාය සේවා ප්‍රවේශය

පහල පැති:

  • AsyncTaskඔබ සිතන තරම් නොවුනත් වඩා කේත සහ සංකීර්ණත්වය
  • ඉල්ලීම් පෝලිම් කර තනි පසුබිම් නූල් මත ධාවනය කරයි . IntentServiceසමාන Serviceක්‍රියාත්මක කිරීමකින් ප්‍රතිස්ථාපනය කිරීමෙන් ඔබට මෙය පහසුවෙන් පාලනය කළ හැකිය , සමහර විට මෙය වැනි ය .
  • මට දැන් වෙන කිසිවෙකු ගැන සිතිය නොහැකිය

ඉහළ පැති:

  • කෙටිකාලීන මතක කාන්දු වීමේ ගැටළුව මඟහරවා ගනී
  • ජාල ක්‍රියාකාරකම් පියාසර කරන අතරතුර ඔබගේ ක්‍රියාකාරකම් නැවත ආරම්භ වේ නම්, එය තවමත් බාගත කිරීමේ ප්‍රති result ලය එහි onActivityResultක්‍රමය හරහා ලබා ගත හැකිය
  • ශක්තිමත් ජාල කේතයක් තැනීමට සහ නැවත භාවිතා කිරීමට AsyncTask ට වඩා හොඳ වේදිකාව. උදාහරණය: ඔබ ඉතා වැදගත් උඩුගත කරන්න අවශ්ය නම්, ඔබ එය කරන්න පුළුවන් AsyncTaskතුළ සිටින Activityනමුත්, පරිශීලක දුරකථන ඇමතුමක් ගැනීමට යෙදුම පිටතට සන්දර්භය-මාරු නම්, පද්ධතිය හැක උඩුගත සූර්යයා පෙර යෙදුම මරා දමනවා. එය ඇති ඉඩකඩ අඩු ක්රියාකාරී සහිත ඉල්ලුම් ඝාතනය කිරීමට Service.
  • ඔබ ඔබේම සමගාමී අනුවාදයක් භාවිතා කරන්නේ නම් IntentService(මා ඉහත සම්බන්ධ කළ ආකාරයටම) ඔබට සමගාමී මුදල් මට්ටම පාලනය කළ හැකිය Executor.

ක්‍රියාත්මක කිරීමේ සාරාංශය

IntentServiceතනි පසුබිම් නූලකින් බාගත කිරීම් සිදු කිරීම සඳහා ඔබට පහසුවෙන් ක්‍රියාත්මක කළ හැකිය.

පියවර 1: IntentServiceබාගත කිරීම සිදු කිරීම සඳහා එකක් සාදන්න . Intentඅමතර දේ හරහා බාගත කළ යුතු දේ ඔබට එය පැවසිය හැකි PendingIntentඅතර ප්‍රති result ලය නැවත ලබා දීමට එය භාවිතා කරන්න Activity:

import android.app.IntentService;
import android.app.PendingIntent;
import android.content.Intent;
import android.util.Log;

import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;

public class DownloadIntentService extends IntentService {

    private static final String TAG = DownloadIntentService.class.getSimpleName();

    public static final String PENDING_RESULT_EXTRA = "pending_result";
    public static final String URL_EXTRA = "url";
    public static final String RSS_RESULT_EXTRA = "url";

    public static final int RESULT_CODE = 0;
    public static final int INVALID_URL_CODE = 1;
    public static final int ERROR_CODE = 2;

    private IllustrativeRSSParser parser;

    public DownloadIntentService() {
        super(TAG);

        // make one and re-use, in the case where more than one intent is queued
        parser = new IllustrativeRSSParser();
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        PendingIntent reply = intent.getParcelableExtra(PENDING_RESULT_EXTRA);
        InputStream in = null;
        try {
            try {
                URL url = new URL(intent.getStringExtra(URL_EXTRA));
                IllustrativeRSS rss = parser.parse(in = url.openStream());

                Intent result = new Intent();
                result.putExtra(RSS_RESULT_EXTRA, rss);

                reply.send(this, RESULT_CODE, result);
            } catch (MalformedURLException exc) {
                reply.send(INVALID_URL_CODE);
            } catch (Exception exc) {
                // could do better by treating the different sax/xml exceptions individually
                reply.send(ERROR_CODE);
            }
        } catch (PendingIntent.CanceledException exc) {
            Log.i(TAG, "reply cancelled", exc);
        }
    }
}

පියවර 2: මැනිෆෙස්ටයේ සේවාව ලියාපදිංචි කරන්න:

<service
        android:name=".DownloadIntentService"
        android:exported="false"/>

පියවර 3: ප්‍රති result ලය ලබා දීම සඳහා සේවාව භාවිතා කරන PendingResult වස්තුවක් පසුකරමින් ක්‍රියාකාරකමෙන් සේවාව ඉල්ලා සිටින්න:

PendingIntent pendingResult = createPendingResult(
    RSS_DOWNLOAD_REQUEST_CODE, new Intent(), 0);
Intent intent = new Intent(getApplicationContext(), DownloadIntentService.class);
intent.putExtra(DownloadIntentService.URL_EXTRA, URL);
intent.putExtra(DownloadIntentService.PENDING_RESULT_EXTRA, pendingResult);
startService(intent);

පියවර 4: onActivityResult හි ප්‍රති result ලය හසුරුවන්න:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == RSS_DOWNLOAD_REQUEST_CODE) {
        switch (resultCode) {
            case DownloadIntentService.INVALID_URL_CODE:
                handleInvalidURL();
                break;
            case DownloadIntentService.ERROR_CODE:
                handleError(data);
                break;
            case DownloadIntentService.RESULT_CODE:
                handleRSS(data);
                break;
        }
        handleRSS(data);
    }
    super.onActivityResult(requestCode, resultCode, data);
}

සම්පූර්ණ වැඩ කරන ඇන්ඩ්‍රොයිඩ්-ස්ටුඩියෝ / ග්‍රේඩ්ල් ව්‍යාපෘතියක් අඩංගු ගිතුබ් ව්‍යාපෘතියක් මෙහි ඇත.


IntentService යනු මෙය කිරීමට නිවැරදි ක්‍රමය මිස උදුරා නොගැනීම නිසා එය සිදු නොකිරීමට හරියටම AsyncTask වේ.
බ්‍රිල් පැපින්

3
R බ්‍රිල්පැපින් අසින්ක් ටාස්ක් හි අඩුපාඩු අවධාරණය කිරීමට මම මුලුමනින්ම පාහේ එකඟ වන අතර නැවත වචන කියමි. (මම තවමත් තියෙනවා කියලා ඉතා කුඩා ඔබ ඇත්තටම ඔයා කරන්නේ මොකක්ද කියලා නම් - - අවස්ථා සංඛ්යාව එය විය හැකි AsyncTask භාවිතා කිරීම සඳහා OK විය, නමුත් පිළිගත් පිළිතුර ඕනෑම අවාසි පෙන්වා නොවන අතර හොඳ සඳහා මාර්ගය ද ජනප්රිය ඇන්ඩ්‍රොයිඩ් හි).
ස්ටීවි

1
ඔබට ඇත්තටම IllustrativeRSSඅවශ්‍යද? ඔබ RSS දේවල් සමඟ වැඩ නොකරන්නේ නම් කුමක් කළ යුතුද?
කුලුබ්

මගේ මතය අනුව ගූගල් විසින් බර්ඩනය ක්‍රමලේඛකයන්ගේ පැත්තට දැමීමට වඩා කුණු එකතු කිරීම නරක ලෙස ක්‍රියාත්මක කළ යුතුය. මෙහෙයුම් පද්ධතියේ වගකීම මෙයයි. ඇන්ඩ්‍රොයිඩ් ක්‍රියාවට නැංවීමේ මූලික ගැටළුව නිසා ක්‍රමලේඛකයෙකු ඉන්ටෙන්ට් සර්විසස් හෝ සර්විස් භාවිතා කරන්නේ නම්, වසර කිහිපයකට පසු ගූගල් විසින් ඉන්ටෙන්ට් සර්විසස් ද නරක පුරුද්දක් යැයි පවසමින් වෙනත් දෙයක් යෝජනා කරයි. මෙම කථාව දිගටම පවතී ... එබැවින් ගූගල් සංවර්ධකයින් විසින් ඇන්ඩ්‍රොයිඩ් නරක මතක කළමනාකරණය විසඳිය යුත්තේ ක්‍රමලේඛකයන් නොවේ.
saeed khalafinejad

මම දැන් කියන්නට යන්නේ: මෙම පිළිතුර වඩා හොඳ විකල්පයකට වඩා ව්‍යාපෘතිය බෙදා ගැනීමට ඇති ක්‍රමයක් ලෙස පෙනේ AsyncTask. දෝෂය අදහස් කළේ සංවර්ධකයින් UI පසුගාමී වීම වැළැක්වීම සඳහා මිස, අභිප්‍රායන් / සේවාවන් සමූහයක් සමඟ ආරක්ෂාව අවදානමට ලක් කිරීමට අවශ්‍ය නොවන බවයි.
අතහැර දැමූ කරත්ත

144

පැණි වදයේ UI නූල් මත ඔබට ජාල I / O සිදු කළ නොහැක . තාක්ෂණික වශයෙන්, එය වේ ඇන්ඩ්රොයිඩ් පෙර වෙළුම් මත විය හැකි, නමුත් එය ඔබගේ යෙදුම ප්රතිචාර නතර කිරීමට ඇති කරනු ඇති අතර දරුණු ලෙස හැසිරී කරමින් සඳහා ඔබගේ යෙදුම ඝාතනය වන මෙහෙයුම් පද්ධතිය තුළ දැකිය හැක ලෙස එය නරක අදහසක් වේ. ඔබට පසුබිම් ක්‍රියාවලියක් ක්‍රියාත්මක කිරීමට හෝ පසුබිම් නූලකින් ඔබේ ජාල ගනුදෙනුව සිදු කිරීමට අසින්ක් ටාස්ක් භාවිතා කිරීමට අවශ්‍ය වනු ඇත.

ඇන්ඩ්‍රොයිඩ් සංවර්ධක වෙබ් අඩවියේ වේදනා රහිත නූල් දැමීම පිළිබඳ ලිපියක් ඇති අතර එය මේ සඳහා හොඳ හැඳින්වීමක් වන අතර එය යථාර්ථවාදීව මෙහි සැපයිය හැකි පිළිතුරට වඩා හොඳ ගැඹුරක් ඔබට ලබා දෙනු ඇත.


77
  1. දැඩි මාදිලිය භාවිතා නොකරන්න (නිදොස් කිරීමේ ක්‍රමයේදී පමණි)
  2. SDK අනුවාදය වෙනස් නොකරන්න
  3. වෙනම නූල් භාවිතා නොකරන්න

සේවාව හෝ අසින්ක් ටාස්ක් භාවිතා කරන්න

Stack Overflow ප්‍රශ්නයද බලන්න:

android.os.NetworkOnMainThreadException ඇන්ඩ්‍රොයිඩ් වෙතින් විද්‍යුත් තැපෑලක් යැවීම


8
ඔබ සේවාවක් භාවිතා කරන්නේ නම් ඔබට වෙනම ත්‍රෙඩ් එකක් සෑදිය යුතු බව අවධාරණය කිරීම වටී - සේවා ඇමතුම් ආපසු ලබා ගැනීම ප්‍රධාන ත්‍රෙඩ් එකේ ක්‍රියාත්මක වේ. IntentService, අනෙක් අතට, එහි onHandleIntent ක්‍රමය පසුබිම් නූල් මත ධාවනය කරයි.
ස්ටීවි

දිගුකාලීන මෙහෙයුම් සඳහා ඔබ AsyncTask භාවිතා නොකළ යුතුය! මාර්ගෝපදේශ උපරිම තත්පර 2 සිට 3 දක්වා නියම කරයි.
දිනය

76

ජාල ක්‍රියා වෙනත් ත්‍රෙඩ් එකක කරන්න

උදාහරණයක් වශයෙන්:

new Thread(new Runnable(){
    @Override
    public void run() {
        // Do network action in this function
    }
}).start();

මෙය AndroidManifest.xml වෙත එක් කරන්න

<uses-permission android:name="android.permission.INTERNET"/>

5
නමුත් UI ත්‍රෙඩ් එකේ ඊළඟ කාර්යයන් සමූහය සිදු කිරීමට හැකි වන පරිදි ත්‍රෙඩ් එක අවසන් වූ විට අපට දැනගත හැක්කේ කෙසේද? ඒ සඳහා AsyncTask පහසුකම සපයයි. ධාවනය කළ හැකි නූල් භාවිතා කර එයම කිරීමට ක්‍රමයක් තිබේද?
පියුෂ් සෝනි

3
එය ඔබගේ කේතය පියවරෙන් පියවර
ක්‍රියාවට නංවනු ඇත

1
ඔබට අසින්ක් කාර්යය හෝ අභිප්‍රාය සේවාව භාවිතා කළ හැකිය, මන්ද එය සේවක නූල් මත ක්‍රියාත්මක වන බැවිනි.
චෙතන් චෞදාරි

63

පහත කේතය භාවිතයෙන් ඔබ දැඩි ප්‍රකාරය අක්‍රීය කරන්න:

if (android.os.Build.VERSION.SDK_INT > 9) {
    StrictMode.ThreadPolicy policy = 
        new StrictMode.ThreadPolicy.Builder().permitAll().build();
    StrictMode.setThreadPolicy(policy);
}

මෙය නිර්දේශ නොකරයි : AsyncTaskඅතුරු මුහුණත භාවිතා කරන්න .

ක්‍රම දෙකම සඳහා සම්පූර්ණ කේතය


2
ඔව් ANR දෝෂයක් පැමිණෙනු ඇත. තත්පර 5 කින් යෙදුම ප්‍රතිචාර නොදක්වයි.
මුහම්මද් මුබෂීර්

12
මෙය ඇත්තෙන්ම නරක පිළිතුරකි. ඔබ නූල් ප්‍රතිපත්තිය වෙනස් නොකර වඩා හොඳ කේතයක් ලිවිය යුතුය: ප්‍රධාන නූල් මත ජාල මෙහෙයුම් සිදු නොකරන්න!
shkschneider

And සන්දීප් ඔබ සහ අනෙකුත් නරඹන්නන් මෙයද කියවිය යුතුය. stackoverflow.com/a/18335031/3470479
Prakhar1001

53

ජාල පාදක මෙහෙයුම් ප්‍රධාන නූලෙන් ක්‍රියාත්මක කළ නොහැක. ජාල ජාලය මත පදනම් වූ සියලු කාර්යයන් ළමා නූලකින් ක්‍රියාත්මක කිරීමට හෝ අසින්ක් ටාස්ක් ක්‍රියාත්මක කිරීමට ඔබට අවශ්‍යය.

ළමා ත්‍රෙඩ් එකක ඔබ කර්තව්‍යයක් කරන්නේ මෙයයි:

new Thread(new Runnable(){
    @Override
    public void run() {
        try {
            // Your implementation goes here
        } 
        catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}).start();

1
නිර්නාමික ධාවනය කළ හැකි හොඳම ක්‍රමය එය නොවේ, එයට එය සංවෘත පංතිය පිළිබඳ ව්‍යංග සඳහනක් ඇති හෙයින් සහ නූල් සම්පුර්ණ වන තෙක් එය GC සංස්කරණය වීම වළක්වයි! ජීවන චක්‍ර ක්‍රම සහ යූඅයි රාමු අනුපාත සමඟ තරඟ කරමින් මෙම නූල් ප්‍රධාන / එක්සත් ජනපද නූල් ලෙස එකම ප්‍රමුඛතාවයෙන් ක්‍රියාත්මක වේ!
යූෂා අලෙයූබ්

49

ඔබේ කේතය ඇතුළත තබන්න:

new Thread(new Runnable(){
    @Override
    public void run() {
        try {
            // Your implementation
        }
        catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}).start();

හෝ:

class DemoTask extends AsyncTask<Void, Void, Void> {

    protected Void doInBackground(Void... arg0) {
        //Your implementation
    }

    protected void onPostExecute(Void result) {
        // TODO: do something with the feed
    }
}

11 ට වඩා ඉහළින් api සඳහා දෙවැන්න පළමුවැන්නාට වඩා හොඳ වනු ඇත
රෝහිත් ගෝස්වාමි

46

මෙය ඇන්ඩ්‍රොයිඩ් 3.0 සහ ඊට ඉහළින් සිදු වේ. ඇන්ඩ්‍රොයිඩ් 3.0 සහ ඊට ඉහළ සිට, ජාල මෙහෙයුම් (අන්තර්ජාලයට පිවිසෙන කාර්යයන්) ප්‍රධාන නූල් / යූඅයි ත්‍රෙඩ් එකේ ධාවනය කිරීමෙන් ඔවුන් සීමා කර ඇත (ඔබ විසින් නිර්මාණය කරන ලද සහ ක්‍රියාකාරිත්වයේ නැවත ආරම්භ කිරීමේ ක්‍රම වලින්).

මෙය ජාල මෙහෙයුම් සඳහා වෙනම නූල් භාවිතා කිරීම දිරිමත් කිරීමයි. ජාල ක්‍රියාකාරකම් නිවැරදි ආකාරයෙන් සිදු කරන්නේ කෙසේද යන්න පිළිබඳ වැඩි විස්තර සඳහා AsyncTask බලන්න .


46

Android Annotations භාවිතා කිරීම විකල්පයකි. පසුබිම් නූලකින් ඕනෑම ක්‍රමයක් සරලව ක්‍රියාත්මක කිරීමට එය ඔබට ඉඩ සලසයි:

// normal method
private void normal() {
    doSomething(); // do something in background
}

@Background
protected void doSomething() 
    // run your networking code here
}

සටහන, එය සරල බව සහ කියවීමේ හැකියාව ලබා දුන්නද, එහි අවාසි ඇත.


6
Av ගේව්රියෙල් එය ඔබ විවරණය කරන සෑම දෙයකම අනුපිටපත් නිර්මාණය කරයි, එය ක්‍රමයක්, ක්‍රියාකාරකමක්, කැබැල්ලක්, සිංගල්ටන් යනාදිය වේ, එබැවින් කේත මෙන් දෙගුණයක් ඇති අතර එය සම්පාදනය කිරීමට වැඩි කාලයක් ගතවේ. පුස්තකාලයේ ඇති දෝෂ හේතුවෙන් එයට යම් යම් ගැටලු ද ඇති විය හැකිය. නිදොස් කිරීම සහ දෝෂ සොයා ගැනීම වඩාත් අපහසු වනු ඇත.
ඔලෙක්සි

43

දෝෂය සිදුවී ඇත්තේ ප්‍රධාන ත්‍රෙඩ් එකේ දීර් running කාලයක් තිස්සේ ක්‍රියාත්මක වීම නිසාය, ඔබට පහසුවෙන් AsynTask හෝ Thread භාවිතා කිරීමෙන් ගැටළුව නිවැරදි කළ හැකිය . වඩා හොඳින් හැසිරවීම සඳහා ඔබට මෙම පුස්තකාලය AsyncHTTPClient පරීක්ෂා කළ හැකිය .

AsyncHttpClient client = new AsyncHttpClient();
client.get("http://www.google.com", new AsyncHttpResponseHandler() {

    @Override
    public void onStart() {
        // Called before a request is started
    }

    @Override
    public void onSuccess(int statusCode, Header[] headers, byte[] response) {
        // Called when response HTTP status is "200 OK"
    }

    @Override
    public void onFailure(int statusCode, Header[] headers, byte[] errorResponse, Throwable e) {
        // Called when response HTTP status is "4XX" (for example, 401, 403, 404)
    }

    @Override
    public void onRetry(int retryNo) {
        // Called when request is retried
    }
});

42

ඕනෑම ජාල මෙහෙයුමක්, ලිපිගොනු I / O, හෝ SQLite දත්ත සමුදා මෙහෙයුම් වැනි ප්‍රධාන නූල් (UI නූල්) මත ඔබ කාලය නාස්ති කිරීමේ කාර්යයක් නොකළ යුතුය. එබැවින් මේ ආකාරයේ මෙහෙයුමක් සඳහා, ඔබ සේවක නූල් එකක් සෑදිය යුතුය, නමුත් ගැටළුව වන්නේ ඔබේ සේවක නූල් වලින් UI ආශ්‍රිත කිසිදු මෙහෙයුමක් කෙලින්ම කළ නොහැකි වීමයි. ඒ සඳහා, ඔබ භාවිතා කළ යුතු Handlerඅතර සමත් විය යුතුය Message.

මේ සියලු දේ සරල කිරීම සඳහා ඇන්ඩ්රොයිඩ් වැනි, විවිධ ක්රම සපයයි AsyncTask, AsyncTaskLoader, CursorLoaderහෝ IntentService. එබැවින් ඔබේ අවශ්‍යතා අනුව ඔබට මේවායින් ඕනෑම එකක් භාවිතා කළ හැකිය.


40

Spektom හි ඉහළම පිළිතුර පරිපූර්ණව ක්‍රියා කරයි.

ඔබ AsyncTaskපේළිය ලියන්නේ නම් සහ පංතියක් ලෙස විස්තාරණය නොවන්නේ නම් සහ මෙයට ඉහළින් ප්‍රතිචාරයක් ලබා ගැනීමේ අවශ්‍යතාවයක් තිබේ නම් AsyncTask, get()පහත දැක්වෙන ක්‍රමය භාවිතා කළ හැකිය .

RSSFeed feed = new RetreiveFeedTask().execute(urlToRssFeed).get();

(ඔහුගේ ආදර්ශයෙන්.)


5
භාවිතා get()කිරීම නරක අදහසක් ... එය අසින්ක් ටාස්ක් නැවත "සමමුහුර්ත" කරයි
සෙල්වින්

ඊට වඩා හොඳ වෙනස් ක්‍රමයක් තිබේද? El සෙල්වින්
sivag1

2
ප්‍රති result ලය පිළිබඳ ප්‍රධාන ත්‍රෙඩ් එක ඔබට දැනුම් දිය හැකි යැයි මම සිතමි. නිදසුනක් ලෙස, ප්‍රති .ලය ඇතුළුව ප්‍රධාන නූලට විකාශනයක් යවන්න.
චයින් ගැරී

32

මෙය විසි කරනු ලබන්නේ පැණි වද SDK හෝ ඊට වැඩි ඉලක්ක කරගත් යෙදුම් සඳහා පමණි . පෙර SDK අනුවාදයන් ඉලක්ක කරගත් යෙදුම් වලට ඒවායේ ප්‍රධාන සිදුවීම් ලූප නූල් මත ජාලකරණය කිරීමට අවසර ඇත.

දෝෂය වන්නේ SDK අනතුරු ඇඟවීමයි!


28

මට නම් මෙය මෙයයි:

<uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="10" />

මම මගේ යෙදුම පරීක්ෂා කරමින් සිටි උපාංගය 4.1.2 වන අතර එය SDK අනුවාදය 16 වේ!

ඉලක්කගත අනුවාදය ඔබගේ ඇන්ඩ්‍රොයිඩ් ඉලක්ක පුස්තකාලයට සමාන බවට වග බලා ගන්න. ඔබගේ ඉලක්කගත පුස්තකාලය කුමක්දැයි ඔබට විශ්වාස නැත්නම්, ඔබේ ව්‍යාපෘතිය -> ගොඩනැගීමේ මාවත -> ඇන්ඩ්‍රොයිඩ් මත දකුණු ක්ලික් කරන්න, එය තෝරාගත් එක විය යුතුය.

අනෙක් අය සඳහන් කර ඇති පරිදි, අන්තර්ජාලයට පිවිසීමට නිවැරදි අවසර ඇතුළත් කරන්න:

<uses-permission android:name="android.permission.INTERNET"/>

11
ඔබ මෙහි කරන්නේ කුමක්දැයි මම ඔබට පැහැදිලි කරන්නම්: NetworkOnMainThreadExceptionඔබට කියන ගාඩියන්: ඔබේ පාදයට වෙඩි තියන්න එපා ... ඔබේ විසඳුම: ගාඩියන් නොමැති අතීතයට යමු - දැන් මට වෙඩි තැබිය හැකිය නිදහසේ පාදය
සෙල්වින්

1
මමත් මෙම ප්‍රවේශය ගත් අතර කිසිදු ගැටළුවක් නොවීය. ගාඩියන් සමහර වෙලාවට කලබලයි.
ෆ්‍රැක්ටල් බොබ්

25

මෙය ඔබගේ ක්‍රියාකාරකම තුළ භාවිතා කරන්න

    btnsub.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    // TODO Auto-generated method stub

                    //Initialize soap request + add parameters
                    SoapObject request = new SoapObject(NAMESPACE, METHOD_NAME1);

                    //Use this to add parameters
                    request.addProperty("pincode", txtpincode.getText().toString());
                    request.addProperty("bg", bloodgroup.getSelectedItem().toString());

                    //Declare the version of the SOAP request
                    SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);

                    envelope.setOutputSoapObject(request);
                    envelope.dotNet = true;

                    try {
                        HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);

                        //this is the actual part that will call the webservice
                        androidHttpTransport.call(SOAP_ACTION1, envelope);

                        // Get the SoapResult from the envelope body.
                        SoapObject result = (SoapObject) envelope.getResponse();
                        Log.e("result data", "data" + result);
                        SoapObject root = (SoapObject) result.getProperty(0);
                        // SoapObject s_deals = (SoapObject) root.getProperty(0);
                        // SoapObject s_deals_1 = (SoapObject) s_deals.getProperty(0);
                        //

                        System.out.println("********Count : " + root.getPropertyCount());

                        value = new ArrayList<Detailinfo>();

                        for (int i = 0; i < root.getPropertyCount(); i++) {
                            SoapObject s_deals = (SoapObject) root.getProperty(i);
                            Detailinfo info = new Detailinfo();

                            info.setFirstName(s_deals.getProperty("Firstname").toString());
                            info.setLastName(s_deals.getProperty("Lastname").toString());
                            info.setDOB(s_deals.getProperty("DOB").toString());
                            info.setGender(s_deals.getProperty("Gender").toString());
                            info.setAddress(s_deals.getProperty("Address").toString());
                            info.setCity(s_deals.getProperty("City").toString());
                            info.setState(s_deals.getProperty("State").toString());
                            info.setPinecode(s_deals.getProperty("Pinecode").toString());
                            info.setMobile(s_deals.getProperty("Mobile").toString());
                            info.setEmail(s_deals.getProperty("Email").toString());
                            info.setBloodgroup(s_deals.getProperty("Bloodgroup").toString());
                            info.setAdddate(s_deals.getProperty("Adddate").toString());
                            info.setWaight(s_deals.getProperty("waight").toString());
                            value.add(info);
                        }

                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    Intent intent = new Intent(getApplicationContext(), ComposeMail.class);
                    //intent.putParcelableArrayListExtra("valuesList", value);

                    startActivity(intent);
                }
            }).start();
        }
    });

23

යමක් පැහැදිලිව උච්චාරණය කිරීමට:

ප්රධාන නූල් මූලික වශයෙන් UI නූල් වේ.

එබැවින් ඔබට ප්‍රධාන ත්‍රෙඩ් එකේ ජාලකරණ මෙහෙයුම් කළ නොහැකි යැයි කීමෙන් අදහස් කරන්නේ ඔබට*runOnUiThread(new Runnable() { ... }* යූඅයි ත්‍රෙඩ් එකේ ජාලකරණ මෙහෙයුම් කළ නොහැකි බවයි, එයින් අදහස් කරන්නේ ඔබට වෙනත් ත්‍රෙඩ් එකක බ්ලොක් එකක ජාලකරණ මෙහෙයුම් කළ නොහැකි බවයි.

(මගේ ප්‍රධාන නූල හැර වෙනත් තැනක මට එම දෝෂය ඇති වූයේ මන්දැයි වටහා ගැනීමට දිගු හිස සීරීමේ මොහොතක් මට තිබුණි. මේ නිසා ය; මෙම නූල උදව් විය; මෙම ප්‍රකාශය වෙනත් කෙනෙකුට උපකාරී වනු ඇතැයි මම බලාපොරොත්තු වෙමි.)


22

මෙම ව්‍යතිරේකය සිදුවන්නේ එම කාර්යය සඳහා වැඩි කාලයක් ගත වුවහොත් ප්‍රධාන නූල් මත සිදු කෙරෙන ඕනෑම බර කාර්යයක් නිසාය .

මෙය වළක්වා ගැනීම සඳහා, අපට එය නූල් හෝ ක්‍රියාත්මක කරන්නන් භාවිතයෙන් හැසිරවිය හැකිය

Executors.newSingleThreadExecutor().submit(new Runnable() {
    @Override
    public void run() {
        // You can perform your task here.
    }
});

18

මෙම ප්‍රශ්නයට දැනටමත් හොඳ පිළිතුරු රාශියක් ඇත, නමුත් එම පිළිතුරු පළ කිරීමෙන් පසු විශාල පුස්තකාල රාශියක් එළියට පැමිණ තිබේ. මෙය නවක-මාර්ගෝපදේශකයක් ලෙස අදහස් කෙරේ.

මම ජාලය මෙහෙයුම් සහ සිදු කිරීම සඳහා භාවිතා වූ අවස්ථා කිහිපයක් ආවරණය වනු ඇත එය එක් එක් සඳහා විසඳුමක් හෝ දෙකක්.

HTTP හරහා නැවත යොමු කරන්න

සාමාන්‍යයෙන් Json, XML හෝ වෙනත් දෙයක් විය හැකිය

සම්පූර්ණ API ප්‍රවේශය

කොටස් මිල ගණන්, පොලී අනුපාත සහ වක්‍ර විනිමය අනුපාත නිරීක්ෂණය කිරීමට පරිශීලකයින්ට ඉඩ දෙන යෙදුමක් ඔබ ලියන බව කියමු. ඔබට මේ වගේ පෙනුමක් ඇති Json API එකක් හමු වේ:

http://api.example.com/stocks                       //ResponseWrapper<String> object containing a list of Srings with ticker symbols
http://api.example.com/stocks/$symbol               //Stock object
http://api.example.com/stocks/$symbol/prices        //PriceHistory<Stock> object
http://api.example.com/currencies                   //ResponseWrapper<String> object containing a list of currency abbreviation
http://api.example.com/currencies/$currency         //Currency object
http://api.example.com/currencies/$id1/values/$id2  //PriceHistory<Currency> object comparing the prices of the first currency (id1) to the second (id2)

චතුරස්රයේ සිට නැවත සකස් කිරීම

බහුවිධ අන්ත ලක්ෂ්‍ය සහිත API සඳහා මෙය කදිම තේරීමක් වන අතර අයන හෝ වොලී වැනි වෙනත් පුස්තකාල මෙන් තනි තනිව කේත කිරීම වෙනුවට REST අන්ත ලක්ෂ්‍ය ප්‍රකාශ කිරීමට ඔබට ඉඩ සලසයි. (වෙබ් අඩවිය: http://square.github.io/retrofit/ )

මූල්‍ය API සමඟ ඔබ එය භාවිතා කරන්නේ කෙසේද?

build.gradle

ඔබේ මොඩියුල මට්ටමට මෙම රේඛා එක් කරන්න buid.gradle:

implementation 'com.squareup.retrofit2:retrofit:2.3.0' //retrofit library, current as of September 21, 2017
implementation 'com.squareup.retrofit2:converter-gson:2.3.0' //gson serialization and deserialization support for retrofit, version must match retrofit version

FinanceApi.java

public interface FinancesApi {
    @GET("stocks")
    Call<ResponseWrapper<String>> listStocks();
    @GET("stocks/{symbol}")
    Call<Stock> getStock(@Path("symbol")String tickerSymbol);
    @GET("stocks/{symbol}/prices")
    Call<PriceHistory<Stock>> getPriceHistory(@Path("symbol")String tickerSymbol);

    @GET("currencies")
    Call<ResponseWrapper<String>> listCurrencies();
    @GET("currencies/{symbol}")
    Call<Currency> getCurrency(@Path("symbol")String currencySymbol);
    @GET("currencies/{symbol}/values/{compare_symbol}")
    Call<PriceHistory<Currency>> getComparativeHistory(@Path("symbol")String currency, @Path("compare_symbol")String currencyToPriceAgainst);
}

ෆිනෑන්ස්අපිබිල්ඩර්

public class FinancesApiBuilder {
    public static FinancesApi build(String baseUrl){
        return new Retrofit.Builder()
                    .baseUrl(baseUrl)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build()
                    .create(FinancesApi.class);
    }
}

ෆිනෑන්ස් ෆ්‍රැග්මන්ට් ස්නිපෙට්

FinancesApi api = FinancesApiBuilder.build("http://api.example.com/"); //trailing '/' required for predictable behavior
api.getStock("INTC").enqueue(new Callback<Stock>(){
    @Override
    public void onResponse(Call<Stock> stockCall, Response<Stock> stockResponse){
        Stock stock = stockCall.body();
        //do something with the stock
    }
    @Override
    public void onResponse(Call<Stock> stockCall, Throwable t){
        //something bad happened
    }
}

ඔබගේ API වෙත API යතුරක් හෝ පරිශීලක ටෝකනයක් වැනි වෙනත් ශීර්ෂයක් යැවීමට අවශ්‍ය නම්, රෙට්රොෆිට් මෙය පහසු කරයි (විස්තර සඳහා මෙම පුදුමාකාර පිළිතුර බලන්න: https://stackoverflow.com/a/42899766/1024412 ).

එක් ඕෆ් රීස්ට් ඒපීඅයි ප්‍රවේශය

පරිශීලකයින්ගේ ජීපීඑස් ස්ථානය සොයා බලා එම ප්‍රදේශයේ වර්තමාන උෂ්ණත්වය පරීක්ෂා කර ඔවුන්ට මනෝභාවය පවසන “මනෝ කාලගුණ” යෙදුමක් ඔබ ගොඩනඟමු යැයි කියමු. මෙම වර්ගයේ යෙදුමට API අන්ත ලක්ෂ්‍ය ප්‍රකාශ කිරීමට අවශ්‍ය නොවේ; එයට අවශ්‍ය වන්නේ එක් API අන්ත ලක්ෂ්‍යයකට ප්‍රවේශ විය හැකි වීමයි.

අයන

මෙම වර්ගයේ ප්‍රවේශය සඳහා මෙය විශිෂ්ට පුස්තකාලයකි.

කරුණාකර msysmilu ගේ විශිෂ්ට පිළිතුර කියවන්න ( https://stackoverflow.com/a/28559884/1024412 )

HTTP හරහා පින්තූර පූරණය කරන්න

වොලි

ReST API සඳහා වොලී ද භාවිතා කළ හැකිය, නමුත් අවශ්‍ය වඩාත් සංකීර්ණ සැකසුම නිසා මම ඉහත පරිදි චතුරස්රයේ සිට Retrofit භාවිතා කිරීමට කැමැත්තෙමි ( http://square.github.io/retrofit/ )

ඔබ සමාජ ජාල යෙදුමක් සාදන බවත්, මිතුරන්ගේ පැතිකඩ පින්තූර පූරණය කිරීමට අවශ්‍ය බවත් කියමු.

build.gradle

ඔබේ මොඩියුල මට්ටමට මෙම රේඛාව එක් කරන්න buid.gradle:

implementation 'com.android.volley:volley:1.0.0'

ImageFetch.java

වොලිට Retrofit වලට වඩා වැඩි සැකසුමක් අවශ්‍ය වේ. RequestQueue, ImageLoader සහ ImageCache සැකසීමට ඔබට මේ වගේ පන්තියක් නිර්මාණය කිරීමට අවශ්‍ය වනු ඇත, නමුත් එය එතරම් නරක නැත:

public class ImageFetch {
    private static ImageLoader imageLoader = null;
    private static RequestQueue imageQueue = null;

    public static ImageLoader getImageLoader(Context ctx){
        if(imageLoader == null){
            if(imageQueue == null){
                imageQueue = Volley.newRequestQueue(ctx.getApplicationContext());
            }
            imageLoader = new ImageLoader(imageQueue, new ImageLoader.ImageCache() {
                Map<String, Bitmap> cache = new HashMap<String, Bitmap>();
                @Override
                public Bitmap getBitmap(String url) {
                    return cache.get(url);
                }
                @Override
                public void putBitmap(String url, Bitmap bitmap) {
                    cache.put(url, bitmap);
                }
            });
        }
        return imageLoader;
    }
}

user_view_dialog.xml

පින්තූරයක් එක් කිරීම සඳහා පහත දැක්වෙන දෑ ඔබේ පිරිසැලසුම් xml ගොනුවට එක් කරන්න:

<com.android.volley.toolbox.NetworkImageView
    android:id="@+id/profile_picture"
    android:layout_width="32dp"
    android:layout_height="32dp"
    android:layout_alignParentTop="true"
    android:layout_centerHorizontal="true"
    app:srcCompat="@android:drawable/spinner_background"/>

UserViewDialog.java

OnCreate ක්‍රමයට (කොටස්, ක්‍රියාකාරකම්) හෝ ඉදිකිරීම්කරු (ඩයලොග්) වෙත පහත කේතය එක් කරන්න:

NetworkImageView profilePicture = view.findViewById(R.id.profile_picture);
profilePicture.setImageUrl("http://example.com/users/images/profile.jpg", ImageFetch.getImageLoader(getContext());

පිකාසෝ

චතුරස්රයේ තවත් විශිෂ්ට පුස්තකාලයක්. හොඳ උදාහරණ කිහිපයක් සඳහා කරුණාකර වෙබ් අඩවිය බලන්න: http://square.github.io/picasso/


16

සරල වචන වලින්,

UI ත්‍රෙඩ් එකේ නෙට්වර්ක් වැඩ කරන්න එපා

උදාහරණයක් ලෙස, ඔබ HTTP ඉල්ලීමක් කරන්නේ නම්, එය ජාල ක්‍රියාවකි.

විසඳුමක්:

  1. ඔබ නව ත්‍රෙඩ් එකක් සෑදිය යුතුයි
  2. නැතහොත් AsyncTask පන්තිය භාවිතා කරන්න

මාර්ගය:

ඔබගේ සියලු වැඩ ඇතුළට දමන්න

  1. run() නව නූල් ක්‍රමය
  2. හෝ doInBackground() AsyncTask පන්තියේ ක්‍රමය.

ඒත්:

ඔබ ජාල ප්‍රතිචාරයෙන් යමක් ලබාගෙන එය ඔබගේ දර්ශනයට පෙන්වීමට අවශ්‍ය වූ විට (පෙළ දර්ශනයේ දර්ශන ප්‍රතිචාර පණිවිඩය වැනි), ඔබ නැවත UI ත්‍රෙඩ් එකට යා යුතුය.

ඔබ එය නොකරන්නේ නම්, ඔබට ලැබෙනු ඇත ViewRootImpl$CalledFromWrongThreadException.

කොහොමද?

  1. AsyncTask භාවිතා කරන අතරතුර, onPostExecute()ක්‍රමයෙන් දර්ශනය යාවත්කාලීන කරන්න
  2. නැතහොත් ඇමතුම් runOnUiThread()ක්‍රමය සහ ක්‍රමය තුළ දර්ශනය යාවත්කාලීන කරන්න run().

12

ඔබ අඩුකිරීමේ තවත් නූල් ඔබගේ කේතය කොටසක් ඉවත් කිරීමට හැකි main threadසහ වැලැක්විමට ලබා ANR , NetworkOnMainThreadException , IllegalStateException (එය විය හැකි කාලය දීර්ඝ කාල පරිච්ඡේදයක් සඳහා UI ලොක් හැකි බැවින්, ප්රධාන නූල් මත උදා කළ හැකි ද පිවිසිය නොහැකි දත්ත).

තත්වය මත පදනම්ව ඔබ තෝරා ගත යුතු ප්‍රවේශයන් කිහිපයක් තිබේ

Java Thread හෝ Android HandlerThread

ජාවා නූල් යනු එක් වරක් පමණක් භාවිතා වන අතර එහි ධාවන ක්‍රමය ක්‍රියාත්මක කිරීමෙන් පසුව මිය යයි.

හෑන්ඩ්ලර් ත්‍රෙඩ් යනු ලූපයක් ඇති නව නූලක් ආරම්භ කිරීම සඳහා පහසු පන්තියකි.

අසින්ක් ටාස්ක්

AsyncTask නිර්මාණය කර ඇත්තේ Thread සහ Handler වටා උපකාරක පන්තියක් ලෙස වන අතර එය සාමාන්‍ය නූල් රාමුවක් නොවේ. කෙටි මෙහෙයුම් සඳහා AsyncTasks ඉතා මැනවින් භාවිතා කළ යුතුය (උපරිම වශයෙන් තත්පර කිහිපයක්.) ඔබට නූල් දිගු කාලයක් පවත්වා ගෙන යාමට අවශ්‍ය නම්, java.util.concurrent පැකේජය මඟින් සපයන විවිධ API භාවිතා කිරීම රෙකමදාරු කරනු ලැබේ. ක්‍රියාත්මක කරන්නා , ThreadPoolExecutor සහ FutureTask .

ප්‍රධාන නූල් යූඅයි සංරචක ඒකාධිකාරී කර ඇති හෙයින් සමහර දර්ශනය වෙත ප්‍රවේශ විය නොහැක, ඒ නිසා හැන්ඩ්ලර් ගලවා ගනී

නූල් තටාක ක්‍රියාත්මක කිරීම ThreadPoolExecutor , උපලේඛනගත ThreadPoolExecutor ...

නූල් තටාකය මත හොඳ පාලනයක් ලබා දෙන ExecutorService ක්‍රියාත්මක කරන ThreadPoolExecutor පන්තිය (උදා: මූලික තටාකයේ ප්‍රමාණය, උපරිම තටාකයේ ප්‍රමාණය, ජීවමාන කාලය තබා ගැනීම ආදිය)

උපලේඛනගත ThreadPoolExecutor - ThreadPoolExecutor විස්තාරණය කරන පන්තියකි. යම් ප්‍රමාදයකින් හෝ වරින් වර එය කාර්යයන් උපලේඛනගත කළ හැකිය.

අනාගත කාර්යය

ෆියුචර් ටාස්ක් අසමමුහුර්ත සැකසුම් සිදු කරයි, කෙසේ වෙතත්, ප්‍රති result ලය තවමත් සුදානම් නැතිනම් හෝ සැකසීම සම්පූර්ණ වී නොමැති නම්, ඇමතුම් ලබා ගන්න () නූල් අවහිර කරනු ඇත

AsyncTaskLoaders

AsyncTaskLoaders AsyncTask ට ආවේනික වූ ගැටලු රාශියක් විසඳන බැවින්

IntentService

ඇන්ඩ්‍රොයිඩ් හි දිගුකාලීන සැකසුම් සඳහා වන defacto තේරීම මෙයයි, හොඳ උදාහරණයක් වනුයේ විශාල ගොනු උඩුගත කිරීම හෝ බාගත කිරීමයි. පරිශීලකයා යෙදුමෙන් ඉවත් වුව ද උඩුගත කිරීම සහ බාගැනීම දිගටම පැවතිය හැකි අතර මෙම කාර්යයන් සිදුවන අතරතුර පරිශීලකයාට යෙදුම භාවිතා කිරීමට නොහැකි වීම ඔබට නිසැකවම අවශ්‍ය නොවේ.

ජොබ්ෂෙඩුලර්

Eff ලදායී ලෙස, ඔබ සේවාවක් නිර්මාණය කළ යුතු අතර ජොබ්ඉන්ෆෝ.බිල්ඩර් භාවිතයෙන් රැකියාවක් නිර්මාණය කළ යුතුය.

RxJava

නිරීක්ෂණය කළ හැකි අනුපිළිවෙල භාවිතා කරමින් අසමමුහුර්ත හා සිදුවීම් පදනම් කරගත් වැඩසටහන් රචනා කිරීම සඳහා පුස්තකාලය.

කොරෝටයින් ( කොට්ලින් )

එහි ප්‍රධාන සාරාංශය නම්, එය අසමමුහුර්ත කේතය සමමුහුර්ත ලෙස පෙනේ

වැඩිදුර කියවන්න මෙතැන , මෙන්න , මෙන්න , මෙන්න


මා වෙනුවෙන් වැඩ කළා ... මම AsyncTask පුළුල් ලෙස භාවිතා කර ඇත, නමුත් එක් කාර්යයක් ක්‍රියාත්මක වන විට තවත් කාර්යයක් බලා සිටිනු ඇත. මට මෙය විසඳීමට අවශ්‍යයි. දැන් executeonexecutor සමඟ වැඩ කිරීම. අඩු මතක උපාංගවල එය ක්‍රියා කරන්නේ කෙසේදැයි බලමු.
සුරාජ් ෂින්ගාඩේ

කරුණාකර ක්‍රමය දෙස බලන්න: asyncTask.executeOnExecutor (AsyncTask.THREAD_POOL_EXECUTOR, පරාමිති); ඔබේ කාර්යය එකවර ක්‍රියාත්මක කිරීමට
yoAlex5

10

ඉහත විශාල විසඳුම් සංචිතයක් ඇතත් කිසිවෙකු සඳහන් කර නැත com.koushikdutta.ion: https://github.com/koush/ion

එය අසමමුහුර්ත සහ භාවිතා කිරීමට ඉතා සරල ය:

Ion.with(context)
.load("http://example.com/thing.json")
.asJsonObject()
.setCallback(new FutureCallback<JsonObject>() {
   @Override
    public void onCompleted(Exception e, JsonObject result) {
        // do stuff with the result or error
    }
});

10

නව Threadසහ අසින්ක් ටාස්ක් විසඳුම් දැනටමත් පැහැදිලි කර ඇත.

AsyncTaskකෙටි මෙහෙයුම් සඳහා ඉතා මැනවින් භාවිතා කළ යුතුය. සාමාන්‍ය Threadඇන්ඩ්‍රොයිඩ් සඳහා වඩාත් සුදුසු නොවේ.

HandlerThread සහ Handler භාවිතා කරමින් විකල්ප විසඳුමක් දෙස බලන්න

හෑන්ඩ්ලර් ත්‍රෙඩ්

ලූපයක් ඇති නව නූලක් ආරම්භ කිරීම සඳහා හැන්ඩි පන්තිය. හසුරුවන පන්ති නිර්මාණය කිරීම සඳහා ලූපය භාවිතා කළ හැකිය. එය start()තවමත් හැඳින්විය යුතු බව සලකන්න .

හසුරුවන්නා:

නූල් පණිවිඩ පණිවිඩයක් හා සම්බන්ධ පණිවුඩ සහ ධාවනය කළ හැකි වස්තු යැවීමට සහ සැකසීමට හෑන්ඩ්ලර් ඔබට ඉඩ දෙයි. සෑම හැන්ඩ්ලර් නිදසුනක්ම තනි නූලක් හා එම නූල් පණිවිඩ පෝලිම සමඟ සම්බන්ධ වේ. ඔබ නව හෑන්ඩ්ලර් එකක් සාදන විට, එය නිර්මාණය කරන නූල් පොටට / පණිවිඩ පෝලිමට බැඳී ඇත - එතැන් සිට, එය පණිවුඩ සහ ධාවන පථ එම පණිවිඩ පෝලිමට ලබා දෙන අතර ඒවා පණිවිඩයෙන් එළියට එන විට ක්‍රියාත්මක කරයි. පෝලිම්.

විසඳුමක්:

  1. සාදන්න HandlerThread

  2. අමතන්න start()මතHandlerThread

  3. නිර්මාණය Handlerවෙමින් විසින් LooperසිටHanlerThread

  4. ඔබේ ජාල මෙහෙයුම් සම්බන්ධ කේතය Runnableවස්තුව තුළ කාවැද්දීම

  5. Runnableවෙත කාර්යය ඉදිරිපත් කරන්නHandler

නියැදි කේත ස්නිපටය, කුමන ලිපිනය NetworkOnMainThreadException

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

Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        try {
            Log.d("Ravi", "Before IO call");
            URL page = new URL("http://www.google.com");
            StringBuffer text = new StringBuffer();
            HttpURLConnection conn = (HttpURLConnection) page.openConnection();
            conn.connect();
            InputStreamReader in = new InputStreamReader((InputStream) conn.getContent());
            BufferedReader buff = new BufferedReader(in);
            String line;
            while ( (line =  buff.readLine()) != null) {
                text.append(line + "\n");
            }
            Log.d("Ravi", "After IO call");
            Log.d("Ravi",text.toString());

        }catch( Exception err){
            err.printStackTrace();
        }
    }
};
mainHandler.post(myRunnable);

මෙම ප්‍රවේශය භාවිතා කිරීමේ වාසි:

  1. Thread/AsyncTaskඑක් එක් ජාල මෙහෙයුම් සඳහා නව නිර්මාණය කිරීම මිල අධිකය. මෙම Thread/AsyncTaskඉදිරි ජාලය මෙහෙයුම් සඳහා විනාශ වනු ඇති අතර, නැවත නිර්මාණය. නමුත් ප්‍රවේශය Handlerහා HandlerThreadප්‍රවේශය අනුව, ඔබට බොහෝ ජාල මෙහෙයුම් (ධාවනය කළ හැකි කාර්යයන් ලෙස) HandlerThreadභාවිතා කිරීමෙන් තනිකඩව ඉදිරිපත් කළ හැකිය Handler.

8

මෙම ගැටළුව විසඳීම සඳහා තවත් ඉතා පහසු ක්‍රමයක් තිබේ - rxJava හි සමගාමී හැකියාවන් භාවිතා කරන්න. ඔබට ඕනෑම කාර්යයක් පසුබිමෙන් හා ප්‍රති results ල ප්‍රධාන නූලට ඉතා පහසු ආකාරයකින් ක්‍රියාත්මක කළ හැකිය, එබැවින් මෙම ප්‍රති results ල සැකසුම් දාමයට භාර දෙනු ඇත.

පළමු සත්‍යාපිත පිළිතුරු උපදෙස් වන්නේ AsynTask භාවිතා කිරීමයි. ඔව්, මෙය විසඳුමකි, නමුත් වර්තමානයේ එය යල්පැන ඇත, මන්ද අවට නව මෙවලම් තිබේ.

String getUrl() {
    return "SomeUrl";
}

private Object makeCallParseResponse(String url) {
    return null;
    //
}

private void processResponse(Object o) {

}

GetUrl ක්‍රමය මඟින් URL ලිපිනය සපයන අතර එය ප්‍රධාන ත්‍රෙඩ් එකේ ක්‍රියාත්මක වේ.

makeCallParseResponse (..) - සත්‍ය ලෙස ක්‍රියා කරයි

processResponse (..) - ප්‍රධාන ත්‍රෙඩ් එකේ ප්‍රති result ල හසුරුවනු ඇත.

අසමමුහුර්තව ක්‍රියාත්මක කිරීම සඳහා වූ කේතය පහත පරිදි වේ:

rx.Observable.defer(new Func0<rx.Observable<String>>() {
    @Override
    public rx.Observable<String> call() {
        return rx.Observable.just(getUrl());
    }
})
    .subscribeOn(Schedulers.io())
    .observeOn(Schedulers.io())
    .map(new Func1<String, Object>() {
        @Override
        public Object call(final String s) {
            return makeCallParseResponse(s);
        }
    })
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Action1<Object>() {
        @Override
        public void call(Object o) {
             processResponse(o);
        }
    },
    new Action1<Throwable>() {
        @Override
        public void call(Throwable throwable) {
            // Process error here, it will be posted on
            // the main thread
        }
    });

AsyncTask හා සසඳන විට, මෙම ක්‍රමය මඟින් උපලේඛනගත කරන්නන්ට අත්තනෝමතික වාර ගණනක් මාරු කිරීමට ඉඩ ලබා දේ (එනම්, එක් උපලේඛකයෙකුගෙන් දත්ත ලබා ගැනීමට සහ එම දත්ත තවත් එකක් මත සැකසීමට (කියන්න, Scheduler.computation ()), ඔබට ඔබේම උපලේඛන නිර්වචනය කළ හැකිය.

මෙම පුස්තකාලය භාවිතා කිරීම සඳහා, ඔබට build.gradle ගොනුවට පහත පේළි ඇතුළත් කරන්න:

   compile 'io.reactivex:rxjava:1.1.5'
   compile 'io.reactivex:rxandroid:1.2.0'

අවසාන පරායත්තතාවයට .mainThread () උපලේඛනය සඳහා සහාය ඇතුළත් වේ.

නැත rx-ජාවා සඳහා විශිෂ්ට සඟරාව ඉලෙක්ට්රොනික පොත් ලෙස අවපතනය .


තරමක් පුළුල් ප්‍රවේශයක් එය අපේම කාලසටහනකට අනුව සකස් කළ යුතු අතර එය දැනටමත් ඇන්ඩ්‍රොයිඩ් පැත්තේ විකල්පයක් නම් අප එසේ කළ යුත්තේ මන්දැයි මම නොදනිමි.
ප්‍රඛාර් 1001

8

RxAndroidමෙම ගැටළුවට තවත් හොඳ විකල්පයක් වන අතර එය නූල් සෑදීමෙන් හා ඇන්ඩ්‍රොයිඩ් යූඅයි නූල්වල ප්‍රති results ල පළ කිරීමෙන් ඇති වන කරදර වලින් අපව ගලවා ගනී. අපට අවශ්‍ය වන්නේ කුමන කාර්යයන් ඉටු කළ යුතුද යන්න සහ සියල්ල අභ්‍යන්තරව හසුරුවනු ලබන නූල් නියම කිරීමයි.

Observable<List<String>> musicShowsObservable = Observable.fromCallable(new Callable<List<String>>() { 

  @Override 
  public List<String> call() { 
    return mRestClient.getFavoriteMusicShows(); 
  }
});

mMusicShowSubscription = musicShowsObservable
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<List<String>>() {

    @Override 
    public void onCompleted() { }

    @Override 
    public void onError(Throwable e) { }

    @Override 
    public void onNext(List<String> musicShows){
        listMusicShows(musicShows);
    }
});
  1. නියම කිරීමෙන් (Schedulers.io()), RxAndroid getFavoriteMusicShows() වෙනත් ත්‍රෙඩ් එකක් මත ධාවනය වේ.

  2. භාවිතා කිරීමෙන් AndroidSchedulers.mainThread()අපට UI නූල් මත මෙම නිරීක්‍ෂණය නිරීක්ෂණය කළ යුතුය, එනම් අපගේ onNext()ඇමතුම UI නූල් මත කැඳවීමට අපට අවශ්‍යය


8

ප්‍රධාන නූල UI නූල් වන අතර පරිශීලක අන්තර්ක්‍රියා අවහිර කළ හැකි ප්‍රධාන ත්‍රෙඩ් එකේ ඔබට මෙහෙයුමක් කළ නොහැක. ඔබට මෙය ක්‍රම දෙකකින් විසඳිය හැකිය:

මේ වගේ ප්‍රධාන ත්‍රෙඩ් එකේ කාර්යය කරන්න බල කරන්න

StrictMode.ThreadPolicy threadPolicy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
StrictMode.setThreadPolicy(threadPolicy);

නැතහොත් සරල හසුරුවන්නෙකු නිර්මාණය කර ඔබට අවශ්‍ය නම් ප්‍රධාන නූල යාවත්කාලීන කරන්න.

Runnable runnable;
Handler newHandler;

newHandler = new Handler();
runnable = new Runnable() {
    @Override
    public void run() {
         try {
            //update UI
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
};
newHandler.post(runnable);

නූල් භාවිතය නැවැත්වීමට:

newHandler.removeCallbacks(runnable);

වැඩි විස්තර සඳහා මෙය පරීක්ෂා කරන්න: වේදනා රහිත නූල්


ස්තූතියි. OnCreate හි පළමු ක්‍රියාව ලෙස එකතු කිරීමේදී අනුවාදය 1 උපකාරී වේ.
ඉන්ගෝ

7

මෙය ක්‍රියාත්මක වේ. ආචාර්ය ලුයිජිගේ පිළිතුර ටිකක් සරල කළා.

new Thread() {
    @Override
    public void run() {
        try {
            //Your code goes here
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}.start();

7

ඇන්ඩ්‍රොයිඩ් හි, ජාල ක්‍රියාකාරිත්වය ප්‍රධාන ත්‍රෙඩ් එකේ ක්‍රියාත්මක කළ නොහැක. ජාල මෙහෙයුම් සිදු කිරීම සඳහා ඔබට Thread, AsyncTask (කෙටිකාලීන කාර්යයන්), සේවාව (දිගුකාලීන කාර්යයන්) භාවිතා කළ හැකිය.

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.