Եկեք մի դատարկ.

Դասարանը հիմա գրեթե դատարկ է։ Եկեք ավելացնենք կոդը ձեռքով: Դասը պետք է ժառանգի վերացական դասից Գործունեությունկամ նրա հարազատները սիրում են FragmentActivity, AppCompatActivityև այլն: Մենք ավելացնում ենք ընդլայնում է Գործունեությունը... Գործունեության դասը պետք է ունենա մեթոդ onCreate ()... Մկնիկի կուրսորը դնում ենք դասի ներսում և ընտրացանկից ընտրում Կոդ | Չեղարկելու մեթոդները(Ctrl + O): Երկխոսության վանդակում մենք փնտրում ենք ցանկալի դասը, որի համար կարող եք մուտքագրել ստեղնաշարի առաջին նիշերը արագ որոնում... Ստեղծված մեթոդում դուք պետք է զանգահարեք մեթոդը setContentView ()որը պատրաստի նշումը կբեռնի էկրանին: Մենք կստանանք այս տարբերակը:

Փաթեթ ru.alexanderklimov.helloworld; ներմուծել android.app.Activity; ներմուծել android.os.Bundle; / ** * Ստեղծվել է Ալեքսանդր Կլիմովի կողմից 01.12.2014թ. * / հանրային դասը AboutActivity-ն ընդլայնում է Activity-ը (@Override protected void onCreate (Bundle savedInstanceState) (super.onCreate (savedInstanceState); setContentView (R.layout.activity_about);))

Հիմա սկսվում է ամենակարեւորը. Մեր խնդիրն է գնալ նոր էկրան, երբ սեղմվում է առաջին էկրանի կոճակը: Վերադարձեք դասի MainActivity... Եկեք գրենք կոճակի սեղմման կարգավորիչ.

Public void onClick (Դիտել դիտում) (Intent intent = նոր մտադրություն (MainActivity.this, AboutActivity.class); startActivity (մտադրություն);)

Այստեղ ես օգտագործեցի դասում նկարագրված կոճակների սեղմումները վարելու մեթոդը:

Նոր էկրան սկսելու համար դուք պետք է ստեղծեք դասի օրինակ Մտադրությունև առաջին պարամետրում նշեք ընթացիկ դասը, իսկ երկրորդ պարամետրում անցման դասը, մենք ունենք սա. Գործունեության մասին... Դրանից հետո մեթոդը կոչվում է startActivity ()որը գործարկում է նոր էկրան:

Եթե ​​այժմ փորձեք փորձարկել հավելվածի աշխատանքը էմուլյատորում, ապա կստանաք սխալի հաղորդագրություն: Ի՞նչ ենք մենք սխալ արել։ Մենք բաց ենք թողել մեկ կարևոր քայլ. Դուք պետք է գրանցեք նորը Գործունեությունմանիֆեստում AndroidManifest.xml... Գտեք այս ֆայլը ձեր նախագծում և կրկնակի սեղմեք դրա վրա: Կբացվի ֆայլի խմբագրման պատուհանը: Ավելացնել նոր պիտակ փակման պիտակից հետո առաջին գործունեության համար. Տպեք ինքներդ և ակտիվորեն օգտագործեք հուշումները: Արդյունքը հետևյալն է.

Այսպիսով, լարային ռեսուրսը հարմար եկավ about_title... Գործարկեք հավելվածը, սեղմեք կոճակը և ստացեք պատուհանը Ծրագրի մասին... Այսպիսով, մենք սովորեցինք, թե ինչպես ստեղծել նոր պատուհան և զանգահարել այն կոճակի սեղմումով: Եվ մենք մեր տրամադրության տակ ունենք մեգա-հարմար ծրագիր. այժմ միշտ ձեռքի տակ կլինի հուշում, թե ինչ է անում կատուն, երբ նա գնում է ձախ:

Եվս մեկ անգամ ձեր ուշադրությունը հրավիրում եմ այն ​​փաստի վրա, որ երկրորդ ստեղծված գործունեության դասը պետք է ժառանգի դասից Գործունեությունկամ նրա նման ( ListActivityև այլն), ունենա XML նշագրման ֆայլ (եթե անհրաժեշտ է) և գրված լինի մանիֆեստում:

Մեթոդը զանգահարելուց հետո startActivity ()կսկսվի նոր գործունեություն (այս դեպքում Գործունեության մասին), այն դառնում է տեսանելի և շարժվում դեպի վազող բաղադրիչները պարունակող կույտի վերին մասը: Մեթոդը կանչելիս ավարտել ()նոր գործունեությունից (կամ երբ կոշտ վերադարձի ստեղնը սեղմված է) այն կփակվի և կհեռացվի կույտից: Մշակողը կարող է նաև անցնել նախորդ (կամ որևէ այլ) գործողություն՝ օգտագործելով նույն մեթոդը: startActivity ().

Ինչպես ստեղծել երրորդ էկրան՝ միջոց ծույլերի համար

Ծրագրավորողները, ինչպես կատուները, ծույլ արարածներ են: Միշտ հիշեք, որ գործունեության համար անհրաժեշտ է ստեղծել նշում և դաս, որը ժառանգում է Գործունեություն, իսկ հետո մի մոռացեք գրանցել դասը մանիֆեստում՝ well nafig։

Այս դեպքում ընտրեք ընտրացանկից Ֆայլ | Նոր | Գործունեություն | Հիմնական գործունեություն(կամ մեկ այլ ձևանմուշ): Հաջորդը, կհայտնվի ծանոթ պատուհանը նոր գործունեություն ստեղծելու համար: Մենք լրացնում ենք պահանջվող դաշտերը։

Սեղմեք կոճակի վրա Ավարտելև գործունեությունը պատրաստ կլինի։ Սա հաստատելու համար բացեք մանիֆեստի ֆայլը և ստուգեք նոր մուտքի առկայությունը: Ես չեմ խոսում դասի և նշագրման ֆայլերի մասին, դրանք իրենք կհայտնվեն ձեր առջև։

Ինքներդ ավելացրեք նոր կոճակ հիմնական գործունեության էկրանին և գրեք կոդը՝ ստեղծված գործունեությանն անցնելու համար։

Սկզբում ես ձեզ խորհուրդ կտայի ձեռքով ստեղծել բոլոր անհրաժեշտ բաղադրիչները նոր գործունեության համար, որպեսզի հասկանաք դասի, նշագրման և մանիֆեստի հարաբերությունները: Եվ երբ ձեռք բերեք այն, կարող եք օգտագործել Activity Creation Wizard-ը՝ ձեր աշխատանքը արագացնելու համար:

Տվյալների փոխանցում գործունեության միջև

Մենք օգտագործեցինք ամենապարզ օրինակը՝ մեկ այլ գործունեության էկրան կանչելու համար: Երբեմն անհրաժեշտ է լինում ոչ միայն նոր էկրան կանչել, այլեւ տվյալներ փոխանցել դրան։ Օրինակ, օգտվողի անունը: Այս դեպքում դուք պետք է օգտագործեք հատուկ տարածք լրացուցիչ տվյալներոր դասարանն ունի Մտադրություն.

Տարածաշրջան լրացուցիչ տվյալներզույգերի ցանկն է բանալին / արժեքըոր փոխանցվում է մտադրության հետ մեկտեղ. Տողերը օգտագործվում են որպես բանալիներ, իսկ արժեքների համար կարող եք օգտագործել ցանկացած պարզունակ տվյալների տիպեր, պրիմիտիվների զանգվածներ, դասի օբյեկտներ Փաթեթև այլն:

Տվյալները մեկ այլ գործունեության փոխանցելու համար օգտագործեք մեթոդը putExtra ():

Intent.putExtra («Բանալին», «Արժեք»);

Ստացող գործունեությունը պետք է կոչի համապատասխան մեթոդ. getIntExtra (), getStringExtra ()և այլն:

Int count = getIntent () GetIntExtra («անուն», 0);

Կրկին կրկնենք նախորդ օրինակը։ Մենք արդեն երեք գործունեություն ունենք. Առաջին գործողությունը կունենա երկու տեքստային դաշտ և կոճակ: Արտաքին տեսքը կարող է լինել հետևյալը.

Երկրորդ գործունեությունը Երկրորդ Գործունեությունտեղադրել տարրը TextView, որում կցուցադրենք առաջին գործողությունից ստացված տեքստը։ Եկեք մեթոդի համար գրենք հետևյալ կոդը onCreate ()երկրորդ գործունեության ժամանակ։

@Override պաշտպանված void onCreate (փաթեթ savedInstanceState) (super.onCreate (savedInstanceState); setContentView (R.layout.activity_second); String օգտվող = «Live»; String նվեր = «donut hole»; TextView infoTextView) find.BView id.textViewInfo); infoTextView.setText (օգտատեր + «, ձեզ տրվել է» + նվեր);)

Եթե ​​մենք հիմա սկսենք ծրագիրը և պարզապես կանչենք երկրորդ պատուհանը, ինչպես նկարագրված է հոդվածի առաջին մասում, մենք կտեսնենք լռելյայն պիտակը Ժիվոտնոե, քեզ բլիթ են տվել... Համաձայնեք, բավականին ամոթ է նման հաղորդագրություններ ստանալը։

Մենք շտկում ենք իրավիճակը. Ավելացրեք կոդը առաջին գործունեության համար.

Public void onClick (View view) (EditText userEditText = (EditText) findViewById (R.id.editTextUser); EditText giftEditText = (EditText) findViewById (R.id.editTextGift); Intent intent = new intentivity (A) / մղեք տեքստը առաջին տեքստային դաշտից օգտվողի անվան բանալին intent.putExtra ("username", userEditText.getText (). toString ()); // մղեք տեքստը երկրորդ տեքստային դաշտից դեպի նվեր ստեղն intent.putExtra ( «նվեր», giftEditText.getText (). toString ()); startActivity (մտադրություն);)

Մենք առարկա ենք տեղադրել հատուկ տարայի մեջ Մտադրություներկու բանալի՝ տեքստային դաշտերից վերցված արժեքներով: Երբ օգտվողը մուտքագրում է տվյալներ տեքստային դաշտերում, նրանք կգնան այս կոնտեյներ և կտեղափոխվեն երկրորդ գործողություն:

Երկրորդ գործողությունը պետք է պատրաստ լինի ստանալ ջերմ հաղորդագրություններ հետևյալ կերպ (թավով).

// Կանխադրված արժեքներ՝ String user = «Live»; Լարային նվեր = «բլիթ փոս»; օգտվող = getIntent () getExtras () getString ("username"); նվեր = getIntent () getExtras () getString («նվեր»); TextView infoTextView = (TextView) findViewById (R.id.textViewInfo); infoTextView.setText (օգտատեր + «, ձեզ տրվել է» + նվեր);

Այժմ հաղորդագրությունը որոշ մարդկանց համար ոչ այնքան վիրավորական, բայց նույնիսկ հաճելի է թվում։ Բարդ օրինակներում տվյալների մշակման ժամանակ ցանկալի է ավելացնել վավերացում։ Կան իրավիճակներ, երբ երկրորդ գործունեությունը սկսում ես դատարկ տվյալների նման դատարկորը կարող է խափանել հավելվածը:

Մեր դեպքում մենք գիտենք, որ սպասում ենք լարային արժեքի, ուստի կոդը կարող է վերագրվել այսպես.

Intent intent = getIntent (); օգտվող = intent.getStringExtra («օգտվողի անուն»);

Օգտվող = getIntent () GetStringExtra («օգտանուն»);

Ծրագիրը մի թերություն ունի՝ պարզ չէ, թե ումից ենք ողջույններ ստանում։ Ցանկացած բարեկիրթ կապիկ չի ընդունի նվեր անանուն աղբյուրից։ Այսպիսով, որպես տնային առաջադրանք, ավելացրեք մեկ այլ տեքստային դաշտ՝ մուտքագրելու հաղորդագրություն ուղարկող օգտատիրոջ անունը:

Google-ը խորհուրդ է տալիս բանալիների համար օգտագործել հետևյալ ձևաչափը՝ ձեր փաթեթի անունը որպես նախածանց, որին հաջորդում է հենց բանալին: Այս դեպքում կարող եք վստահ լինել, որ բանալին եզակի է այլ հավելվածների հետ շփվելիս։ Նման մի բան.

Հանրային վերջնական ստատիկ String USER = "ru.alexanderklimov.myapp.USER";

Ով է շրջանակել կատվին Վասկա - մենք հետ ենք ստանում արդյունքը

Միշտ չէ, որ բավարար է պարզապես տվյալներ փոխանցել մեկ այլ գործունեության: Երբեմն դուք ցանկանում եք հետ ստանալ տեղեկատվություն մեկ այլ գործունեությունից, երբ այն փակեք: Եթե ​​ավելի վաղ մենք օգտագործում էինք մեթոդը startActivity (Մտադրության մտադրություն), ապա կա հարակից մեթոդ startActivityFor Result (Մտադրություն, int RequestCode)... Մեթոդների միջև տարբերությունը լրացուցիչ պարամետրն է RequestCode... Դա հիմնականում ընդամենը մի ամբողջ թիվ է, որը դուք կարող եք ինքներդ կազմել: Դա անհրաժեշտ է, որպեսզի տարբերվի, թե ումից է ստացվել արդյունքը։ Ենթադրենք, դուք ունեք հինգ լրացուցիչ էկրան, և դրանց արժեքներ եք հատկացնում 1-ից 5-ը, և այս կոդից կարող եք որոշել, թե ում արդյունքը պետք է մշակեք: Դուք կարող եք օգտագործել -1 արժեքը, այնուհետև դա կլինի նույնը, ինչ մեթոդը կանչելը startActivity (), այսինքն. ոչ մի արդյունքի չենք հասնի.

Եթե ​​դուք օգտագործում եք մեթոդը startActivityFor Result (), ապա արդյունքը ստանալու համար անհրաժեշտ է կոդի մեթոդը փոխարինել onActivityResult ()և մշակել արդյունքը: Շփոթվե՞լ եք: Օրինակ բերենք.

Ենթադրենք՝ դու հետախույզ ես։ Տեղեկություն կար, որ ռեստորանում գտնվող ազդեցիկ անձի սեղանից երկու կտոր երշիկ և այլ ապրանքներ են գողացել։ Կասկածը ընկավ երեք կասկածյալների վրա՝ ագռավի, շան շան և Վասկա կատուի:

Այցելուներից մեկն իր փոքրիկ iPhone-ից լուսանկարների շարք է տրամադրել.

Կա նաև մեկ այլ վկայի ցուցմունք. Իսկ Վասկան լսում է, բայց ուտում է.

Ստեղծեք նոր նախագիծ Շերլոկերկու գործունեությամբ. Առաջին էկրանին կլինի երկրորդ էկրանին անցնելու կոճակ և տեքստային պիտակ, որում կցուցադրվի գողի անունը:

Երկրորդ էկրանը կունենա ռադիո կոճակների խումբ.

Քանի որ մենք պատասխան ենք ակնկալելու երկրորդ էկրանից, մենք պետք է օգտագործենք մեթոդը startActivityFor Result ()առաջին էկրանին, որտեղ մենք փոխանցում ենք փոփոխականը ԸՆՏՐԵԼ_ԳՈՂորպես պարամետր RequestCode.

Ստատիկ վերջնական մասնավոր int CHOOSE_THIEF = 0; public void onClick (Դիտել v) (Intent questionIntent = նոր մտադրություն (MainActivity.this, ChooseActivity.class); startActivityForResult (questionIntent, CHOOSE_THIEF);)

Նայեք ծածկագրին. Երբ կոճակը սեղմվում է, մենք պատրաստվում ենք աշխատել երկրորդ էկրանի հետ Ընտրեք Գործունեությունև գործարկել երկրորդ էկրանը՝ սպասելով արդյունքին:

Գնացեք երկրորդ էկրան և գրեք երկրորդ գործունեության կոդը:

Հանրային վերջնական ստատիկ String THIEF = "ru.alexanderklimov.sherlock.THIEF"; public void onRadioClick (Դիտել v) (Intent answerIntent = նոր մտադրություն (); switch (v.getId ()) (case R.id.radioDog: answerIntent.putExtra (Գող, «Fucking doggie»); ընդմիջում; դեպք R.id .radioCrow՝ answerIntent.putExtra (Գող, «ագռավ»); ընդմիջում; դեպք R.id.radioCat՝ answerIntent.putExtra (Գող, «Պրժևալսկու ձին»); ընդմիջում; լռելյայն՝ ընդմիջում;) setResult (RESULT_OK, answerIntent), ավարտ ();)

Այստեղ ամեն ինչ պարզ է, երբ հետախույզն ընտրում է հանցագործի անունը, ապա մեթոդի միջոցով putExtra ()մենք փոխանցում ենք բանալին և դրա արժեքը:

Հարմարության համար ընտրելուց հետո անմիջապես փակում ենք երկրորդ պատուհանը և փակելուց առաջ փոխանցում ենք արժեքը RESULT_OKհասկանալի դարձնել, որ ընտրությունը կատարվել է։ Եթե ​​օգտատերը փակում է էկրանը Հետ կոճակի միջոցով, արժեքը կփոխանցվի RESULT_CANCELED.

Մեթոդ setResult ()վերցնում է երկու պարամետր՝ արդյունքի կոդը և ինքնին արդյունքը, որը ներկայացված է որպես մտադրություն: Ստացված ծածկագիրը ցույց է տալիս, թե ինչ արդյունքով է ավարտվել գործունեությունը, որպես կանոն, դա կամ Գործունեություն.RESULT_OKկամ Գործողություն.RESULT_CANCELED... Որոշ դեպքերում կարող է անհրաժեշտ լինել օգտագործել ձեր սեփական վերադարձի կոդը՝ ձեր հավելվածին հատուկ տատանումները կարգավորելու համար: Մեթոդ setResult ()աջակցում է ցանկացած ամբողջ արժեք:

Եթե ​​դուք տվյալները հստակորեն փոխանցեք կոճակի միջոցով, ապա լավ կլինի ավելացնել մեթոդ ավարտել ()փակել երկրորդ գործունեությունը որպես ավելորդ. Եթե ​​անցումը տեղի է ունենում Վերադառնալ կոճակի միջոցով, ապա դա անհրաժեշտ չէ:

Եթե ​​գործունեությունը փակվել է օգտագործողի կողմից, երբ սեղմել է ապարատային վերադարձի կոճակը, կամ եթե մեթոդը ավարտել ()կոչվել է մեթոդից առաջ setResult (), ստացված կոդը կսահմանվի RESULT_CANCELEDև վերադարձված մտադրությունը ցույց կտա արժեքը դատարկ.

Մենք վերադառնում ենք առաջին էկրանին։ Առաջին էկրանը սպասում է պատասխանի երկրորդ էկրանից, այնպես որ դուք պետք է ավելացնեք մեթոդը կոդի մեջ onActivityResult ().

@Override պաշտպանված void onActivityResult (int requestCode, int resultCode, intent data) (super.onActivityResult (requestCode, resultCode, data); TextView infoTextView = (TextView) findViewById (R.id.textViewInfo); if (CHOOSETH=IE) if (resultCode == RESULT_OK) (String thiefname = data.getStringExtra (ChooseActivity.THIEF); infoTextView.setText (thiefname);) else (infoTextView.setText (""); // ջնջել տեքստը)))

Մեթոդն ակնկալում է մուտքային տվյալներ կոդով ԸՆՏՐԵԼ_ԳՈՂ, և եթե այդպիսի տվյալներ են գալիս, ապա բանալին հանում է արժեքը ChooseActivity.THIEFօգտագործելով մեթոդը getStringExtra... Մենք թողարկում ենք ստացված արժեքը TextView(փոփոխական infoTextView): Եթե ​​էկրանին վերադարձել ենք Վերադառնալ կոճակի միջոցով, ապա ուղղակի ջնջում ենք տեքստը։

Երբ երեխայի գործունեությունը փակվում է մայր բաղադրիչի ներսում, կարգավորիչը գործարկվում է onActivityResult ()... Կառավարող onActivityResult ()վերցնում է մի քանի պարամետր:

• Հարցման կոդը: Կոդ, որն օգտագործվել է գործունեությունը սկսելու համար՝ վերադարձնելով արդյունքը
• Արդյունքի կոդը. Երեխայի գործունեության կողմից սահմանված արդյունքի կոդը, որը ցույց է տալիս, թե ինչպես է ավարտվել գործունեությունը: Այն կարող է լինել ցանկացած ամբողջ արժեք, բայց սովորաբար կամ Գործունեություն.RESULT_OKկամ Գործողություն.RESULT_CANCELED
• Տվյալներ. Վերադարձված տվյալները փաթեթավորելու համար օգտագործվող մտադրությունը: Կախված երեխայի գործունեության նպատակից, այն կարող է ներառել բովանդակության ընտրված հատվածը ներկայացնող URI ճանապարհ: Որպես այլընտրանք (կամ լրացուցիչ), երեխայի գործունեությունը կարող է տեղեկատվություն վերադարձնել որպես պարզ արժեքներ, որոնք փաթաթված են մտադրության պարամետրով: հավելյալներ

Եթե ​​երեխայի գործունեությունը անսպասելիորեն դադարեցվել է կամ եթե մինչև այն փակելը արդյունքի կոդ չի նշվել, այս պարամետրը կդառնա Գործողություն.RESULT_CANCELED.

Մենք գործարկում ենք նախագիծը, սեղմում ենք կոճակը և անցնում երկրորդ էկրան: Այնտեղ մենք ընտրում ենք տարբերակներից մեկը։ Եթե ​​ընտրեք ագռավը, էկրանը կփակվի, և առաջին էկրանին կցուցադրվի մեղավորի անունը: Եթե ​​ընտրեք շուն, նրա անունը կցուցադրվի:

Ի դեպ, եթե կատու ընտրեք, նրա անունը չի ցուցադրվի: Ստուգեք այն և համոզվեք ինքներդ: Դուք կհարցնեք, թե ինչու. Տարրական Ուոթսոն! Հանցագործը հաշվի չի առել մեկ կարևոր մանրուք. Ռեստորանը վերահսկվել է տեսախցիկներով, և տեսանյութում երևում է, թե ով է իրականում գողացել նրբերշիկը և շրջանակել կատվին։ Վասկա, սպասիր։

P.S. Եթե ​​սկզբում ինչ-որ բան անհասկանալի էր թվում, ապա գործնականում շատ բան պարզ կդառնա։ Էկրանների միջև տվյալների փոխանցումը սովորական է հավելվածներում, և դուք նորից ու նորից կուսումնասիրեք օրինակը:

P.P.S. Լավագույն ձուկը երշիկն է։ Իմանալով այս թուլությունը՝ դժվար չէր կատվին շրջանակել։

Օգտագործելով զտիչներ

Հոդվածում ես ցույց տվեցի մեկ այլ գործունեության անցնելու սովորական եղանակ, երբ մեթոդում startActivity ()նշված են ընթացիկ դասը և անցման դասը: Ի դեպ, պարտադիր չէ, որ գործունեության դասը լինի ձեր դիմումի մաս: Եթե ​​դուք գիտեք դասի անունը մեկ այլ հավելվածից, կարող եք անցնել դրան: Բայց դուք կարող եք այլ գործունեության գնալ այլ կերպ:

Գործնականում դա ավելի քիչ տարածված է, բայց կարող է օգտակար լինել: Ենթադրենք, դուք արդեն ունեք երկրորդ գործունեություն։ Դրան ավելացրեք հատուկ զտիչ մանիֆեստում.

Եվ մենք գործարկում ենք երկրորդ գործողությունը՝ սեղմելով կոճակը այս կերպ։

Public void onClick (Դիտել տեսք) (startActivity (նոր մտադրություն («ru.alexanderklimov.testapplication.SecondActivity»));

Երկար տողը փոխարինենք հաստատունով։

Հանրային ստատիկ վերջնական տող ACTION_SECOND_ACTIVITY = "ru.alexanderklimov.testapplication.SecondActivity"; public void onClick (Դիտել դիտում) (startActivity (նոր մտադրություն (ACTION_SECOND_ACTIVITY));)

Այսպիսով, ինչ ենք մենք արել: Երկրորդ գործունեության համար մենք ավելացրել ենք զտիչ և նշել դրա անունը գործողությունհատկանիշի մեջ android: անունը... Հարմարության համար ես ուղղակի դնում եմ գործունեության լրիվ անվանումը՝ փաթեթի անվանումով։ Դասի կառուցող Մտադրությունունի մի քանի գերբեռնված տարբերակներ: Մեկ տարբերակում դուք կարող եք նշել գործողության համար տող: Մենք նշել ենք մեր ստեղծված գործողությունը, որը գրանցված է երկրորդ գործունեության մեջ։ Համակարգը դիտում է բոլոր տեղադրված հավելվածների մանիֆեստները շահագործման ընթացքում: Համընկնումը որոնելիս համակարգը գտնում է մեր զտիչը և գործարկում ցանկալի գործունեությունը:

Նույն սկզբունքով կարելի է սկսել այլ գործողություններ: Նայեք օրինակին: Եթե ​​օրինակը պատճենեք ինքներդ ձեզ և նայեք փաստաթղթերին android.provider.Settings.ACTION_AIRPLANE_MODE_SETTINGS, կտեսնեք, որ այս կոդը համապատասխանում է լարային հաստատունին հանրային ստատիկ վերջնական java.lang.String ACTION_AIRPLANE_MODE_SETTINGS = "android.settings.AIRPLANE_MODE_SETTINGS"... Համեմատեք մեր կոդի հետ։ Կարելի է ենթադրել, որ անցանց ռեժիմի կարգավորումների ակտիվության մեջ այս տողը գրված է ֆիլտրում։

Զտել կատեգորիայի անվանումը android.intent.category.DEFAULTասում է համակարգին կատարել լռելյայն գործողությունը, որը պետք է սկսի գործունեությունը: Կան այլ անուններ, որոնք մեզ դեռ չեն հետաքրքրում։

Իսկ հիմա լրացման հարց. Ի՞նչ կլինի, եթե ստեղծեք մեկ այլ գործունեություն և նշեք նույն զտիչը, ինչ երկրորդ գործողությունը: Եկեք ստուգենք այն: Ստեղծեք ձեր մեջ երրորդ գործունեությունը և պատճենեք բլոկը ֆիլտրով երկրորդ գործողությունից դրան:

Սեղմեք կոճակի վրա առաջին գործունեության ընթացքում: Համակարգը կխնդրի ձեզ ընտրել ձեր ուզած տարբերակը:

Եթե ​​ընտրեք նյութը ՄԻՇՏ, հաջորդ անգամ ստիպված չեք լինի ընտրել։ Ընտրությունը վերականգնելու համար անցեք հավելվածի հատկությունները Կարգավորումներում և գտեք կոճակը Մաքրել կանխադրվածները.

Գործունեության վարում իր անունով

Կոնստրուկտորում Մտադրություներկրորդ պարամետրը դասն է: Բայց ենթադրենք, որ կա տվյալների բազա, որտեղ նշված են գործունեության անվանումները, և մենք պետք է գործարկենք անհրաժեշտ գործունեությունը դրա անունով: Մենք կարող ենք բուն դասը ստանալ string փոփոխականի հիման վրա և սկսել գործունեությունը:

Փորձեք (// Գործունեության դասի լրիվ անվանումը String activityName = "ru.alexanderklimov.testapplication.SecondActivity"; // ստացեք Class Class օբյեկտըmyClass = Class.forName (activityName); Intent intent = նոր մտադրություն (սա, myClass); startActivity (մտադրություն); ) բռնել (ClassNotFoundException e) (e.printStackTrace ();)

Ինչ-որ կերպ ես խնդիր ունեի ծառայությունից տվյալներ փոխանցել գործունեությանը: Սկսեցին լուծում փնտրել ստանդարտ SDK-ում, բայց քանի որ ժամանակ չկար, ես վատ լուծում արեցի տվյալների բազայի օգտագործման տեսքով։ Բայց հարցը բաց էր, և որոշ ժամանակ անց ես պարզեցի ավելի ճիշտ ճանապարհ, որը գտնվում է SDK-ում՝ օգտագործելով Message, Handler, Messenger դասերը:

Գաղափար

Մենք պետք է տվյալներ տեղափոխենք գործունեությունից ծառայություն և հակառակը: Ինչպե՞ս ենք մենք դա անում: Մենք արդեն ունենք այն ամենը, ինչ անհրաժեշտ է մեր խնդիրը լուծելու համար։ Ձեզ անհրաժեշտ է միայն bindService-ի միջոցով ծառայությունը կապել գործունեության հետ, փոխանցել անհրաժեշտ պարամետրերը և մի փոքր կախարդանք՝ Message դասերի օգտագործման տեսքով։ Եվ կախարդանքը Message օրինակի փոփոխականներն ու, մասնավորապես, replyTo-ն օգտագործելն է: Մեզ անհրաժեշտ է այս փոփոխականը, որպեսզի կարողանանք ակտիվացումից հղում կատարել ծառայության Messanger օրինակին, իսկ ծառայության մեջ ակտիվացման Messanger օրինակին: Իրականում դա այնքան էլ պարզ չէ. Գոնե իմ ոչ ամենատաղանդավոր մտքի համար: Մասամբ ես պարզապես բարելավում եմ փաստաթղթերը, որոնք արդեն կան՝ Ծառայություններ: Բացի այդ, կա լավ օրինակ StackOverflow-ում: Ամեն դեպքում, հուսով եմ հոդվածը օգտակար կլինի գոնե մեկին ու իզուր չեմ աշխատել։

Օրինակ

Որպես օրինակ՝ մենք կիրականացնենք ծառայություն, որը կավելացնի և կնվազեցնի հաշվիչի արժեքը և արդյունքը կվերադարձնի գործունեությանը՝ TextView: Ես բաց կթողնեմ դասավորության կոդը, քանի որ կան երկու կոճակ և տեքստային դաշտ. ամեն ինչ պարզ է:

Իրականացում

Ես կտամ ակտիվացման ամբողջական կոդը.

MainActivity հանրային դասը ընդլայնում է Activity-ը (հրապարակային ստատիկ վերջնական String TAG = «TestService»; TestServiceConnection testServConn; TextView testTxt; վերջնական Մեսսենջեր մեսենջեր= նոր Messenger (նոր IncomingHandler ()); Messenger toServiceMessenger; @Override public void onCreate (Bundle savedInstanceState) (super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); testTxt = (TextView) findViewById (R.id.test_txt); bind.testService (nthi. ), (testServConn = նոր TestServiceConnection ()), Context.BIND_AUTO_CREATE);) @Override public void onDestroy () (super.onDestroy (); unbindService (testServConn);) public void countIncrClick (Դիտել հաղորդագրությունների կոճակը) =Meg ստանալ (null, TestService.COUNT_PLUS); msg.replyTo = մեսենջեր; փորձել (toServiceMessenger.send (msg);) բռնել (RemoteException e) (e.printStackTrace ();)) հրապարակային անվավեր countDecrClick (Դիտել կոճակ) (Հաղորդագրություն msg = Message.obtain (null, TestService.COUNT_MINUS); msg.replyTo = մեսենջեր; փորձել (toServiceMessenger.send (msg);) catch (RemoteException e) (e.printStackTrace ();)) մասնավոր դաս IncomingHandler ընդլայնում է Handler-ը (@Override public): void handleMessage (Message msg) (switch (msg.what) (case TestServic e.GET_COUNT. Log.d (TAG, «(գործունեություն) ... ստանալ հաշվարկ»); testTxt.setText ("" + msg.arg1); ընդմիջում; ))) մասնավոր դասը TestServiceConnection-ն իրականացնում է ServiceConnection (@Override public void onServiceConnected (ComponentName name, IBinder ծառայություն) (toServiceMessenger = նոր Messenger (ծառայություն); // ուղարկել սկզբնական հաշվիչի արժեքը Message msg = Message.obtain (null.SCOUNT_ETS) msg.replyTo = մեսենջեր; msg.arg1 = 0; // մեր հաշվիչի փորձը (toServiceMessenger.send (msg);) բռնել (RemoteException e) (e.printStackTrace ();)) @Override public void onServiceDisconnected (ComponentName name) ()))

Թույլ տուր բացատրեմ. Ակտիվություն ստեղծելիս մենք անմիջապես կապվում ենք ծառայությանը՝ ներդնելով ServiceConnection ինտերֆեյսը և դրանում հաղորդագրություն ենք ուղարկում ծառայությանը «սահմանել հաշվիչը»՝ անցնելով զրո և ստեղծելով «ServiceMessanger»՝ փոխանցելով IBinder ինտերֆեյսը կոնստրուկտորին։ Ի դեպ, ծառայությունը պետք է վերադարձնի այս օրինակը, հակառակ դեպքում դա կլինի NPE: Մենք օգտագործում ենք այս դասը ծառայությանը հաղորդագրություններ ուղարկելու համար: Եվ ահա դա կախարդական է. replyTo փոփոխականում մենք պահպանում ենք մեր մյուս Messenger օրինակը՝ այն, որը պատասխան է ստանում սերվերից և դրա միջոցով է, որ կապը կիրականացվի գործունեության հետ։

Ծառայությունից հաղորդագրություն ստանալու համար մենք օգտագործում ենք մեր Handler-ը և պարզապես փնտրում ենք մեզ անհրաժեշտ փոփոխականները և կատարում գործողություններ դրանց վրա: Սեղմելով կոճակները (մեթոդներ countIncrClick, countDecrClick) մենք հարցումներ ենք ուղարկում ծառայությանը՝ նշելով ցանկալի գործողությունը msg.what փոփոխականում։

Փաթեթ com.example.servicetest; ներմուծել android.app.Service; ներմուծել android.content.*; ներմուծել android.os. *; ներմուծել android.os.Process; ներմուծել android.util.Log; հանրային դասի TestService ընդլայնում է Ծառայությունը (հրապարակային ստատիկ վերջնական int COUNT_PLUS = 1; հանրային ստատիկ վերջնական int COUNT_MINUS = 2; հանրային ստատիկ վերջնական int SET_COUNT = 0; հանրային ստատիկ վերջնական int GET_COUNT = 3; int count = 0; IncomingHandler inHandler; Messenger Messenger; Messenger; toActivityMessenger; @Override public void onCreate () (super.onCreate (); HandlerThread thread = նոր HandlerThread («ServiceStartArguments», Process.THREAD_PRIORITY_BACKGROUND); thread.start (new) (inHandler);) @Override public IBinder onBind (Intent arg0) (վերադարձնել messanger.getBinder ();) @Override public int onStartCommand (Intent intent, int flags, int startId) (վերադարձնել START_STICKY;) // հաղորդագրությունների մշակող և անձնական դասի Incom ընդլայնում է Handler (public IncomingHandler (Looper looper) (super (looper);) @Override public void handleMessage (Message msg) (//super.handleMessage(msg); toActivityMess enger = msg.replyTo; անջատիչ (msg.what) (գործը SET_COUNT. count = msg.arg1; Log.d (MainActivity.TAG, «(service) ... սահմանել count»); ընդմիջում; դեպք COUNT_PLUS՝ count ++; Log.d (MainActivity .TAG , «(ծառայություն) ... հաշվել գումարած»); ընդմիջում; դեպք COUNT_MINUS. Log.d (MainActivity.TAG, «(ծառայություն) ... հաշվել մինուս»); հաշվել--; ընդմիջում;) // ուղարկել գործողությունների հաշվիչի արժեքը Message outMsg = Message.obtain (inHandler, GET_COUNT); outMsg.arg1 = հաշվում; outMsg.replyTo = մեսենջեր; փորձեք (եթե (toActivityMessenger! = null) toActivityMessenger.send (outMsg);) catch (RemoteException e) (e.printStackTrace ();))))

Բոլորը անալոգիա գործունեության տրամաբանության հետ: Ես նույնիսկ չգիտեմ, արդյոք պետք է ինչ-որ բան բացատրել: Միակ բանն այն է, որ ես անմիջապես հարցում եմ ուղարկում handleMessage-ի գործունեությանը՝ օգտագործելով կախարդական replyTo փոփոխականը և քաշելով վերևում գտնվող ցանկալի Messenger-ը: Եվ երկրորդ կետը, որը ես արդեն նշեցի, հետևյալն է.

@Override public IBinder onBind (Intent arg0) (վերադարձնել messanger.getBinder ();)

առանց որի ամեն ինչ կընկնի: Ինտերֆեյսի այս օրինակն է, որը կփոխանցվի ServiceConnection-ին

Եզրակացություն

Վերջիվերջո. Այսպիսին է գործունեության և ծառայությունների միջև փոխազդեցության հորինված օրինակը: Ինձ թվում է, որ սա բավականին ոչ տրիվիալ փոխազդեցություն է, թեև ինչ-որ մեկին կարող է տարբեր թվալ։

Հարցեր, պարզաբանումներ և ավելին անձնականում։ Կարող են լինել անճշտություններ ցանկացած ասպեկտի վերաբերյալ, այնպես որ ազատ զգալ գրեք և ուղղեք:
Հուսով եմ, որ գրառումը օգտակար էր ընթերցողներին:

Բարեւ Ձեզ.

Անհրաժեշտ է UART-ի միջոցով ստացված տվյալները փոխանցել Activity: Դա կարելի է անել՝ Գործունեության մեջ ստեղծելով շղթա, որտեղ կարելի է կազմակերպել որոշ ժամանակ (! IsInterrupted ()) հանգույց և կարդալ տվյալները UART բուֆերից: Դրանից հետո Activity-ի միջերեսի շարանը զանգահարելով - MainActivity.this.runOnUiThread (նոր Runnable (), կատարեք անհրաժեշտ գործողությունները այս Activity-ի հետ: Բայց եթե մենք կանչենք այլ Activities հիմնական Activity-ից, ապա կազմակերպված շարանը թույլ չի տալիս փոխանցել: տվյալներ նոր ստեղծված Activity-ին Եթե ես ճիշտ եմ հասկանում, որ հոսքի տվյալները ցանկացած Activity-ի փոխանցելու համար հոսքը պետք է ստեղծվի ոչ թե Activity-ում, այլ Service-ում։

Հարց. Տվյալները եկել են UART-ով, հոսքով (որը ստեղծվում է Servce-ում) անհրաժեշտ է տվյալներ փոխանցել Activity-ին, որն այժմ ակտիվ է, ինչպե՞ս կարելի է դա անել և արդյոք դա արվում է ընդհանրապես:

1 պատասխան

Յուրաքանչյուր Գործունեության մեջ ստեղծեք Handler: Այս գործունեության onResume () մեթոդում այն ​​կապում է ծառայությունը (): Այնտեղ պարամետրերից մեկը ինտերֆեյսի ServiceConnection-ն է: Իրականացրե՛ք այն գոնե նույն Գործունեությամբ։ Դրանում ներդրեք onServiceConnected () մեթոդը։ Այս հետ կանչում Ծառայությունն ինքնին գալիս է որպես պարամետրերից մեկը: Այսպիսով, անվանեք այս Ծառայությունը ձեր սեփական setHandler () մեթոդը: Այնտեղ փոխանցեք ընթացիկ Գործունեության մեջ գտնվող Handler-ը: Բայց ուղարկեք մուտքային տվյալները UART-ի միջոցով այս Handler-ի ծառայությանը: Ի դեպ, Handler-ը ավանդաբար աշխատում է հիմնական թեմայի վրա, ուստի գործարկելու համար կարիք չի լինի գործարկել OnUiThread-ը: