Գեղեցկությունը բեկորներից. Ինչպես բարելավել UI-ն Android-ում՝ օգտագործելով Fragment դասը: Android բեկորների հատվածի կյանքի ցիկլը

Նկար 2.Ֆրագմենտի կյանքի ցիկլը (շահագործման ընթացքում)

Հատված ստեղծելու համար պետք է դասակարգել դասը (կամ դրա գոյություն ունեցող ենթադասը): Դասարանը ունի կոդ, որը շատ նման է . Այն պարունակում է հետ կանչելու մեթոդներ, որոնք նման են գործառնական մեթոդներին, ինչպիսիք են և . Գործնականում, եթե անհրաժեշտ է փոխարկել գոյություն ունեցող հավելված Android-ում ֆրագմենտներ օգտագործելու համար դուք պարզապես կոդը տեղափոխում եք գործողության հետ կանչման մեթոդներից համապատասխան հատվածի հետ կանչման մեթոդներ:

Որպես կանոն, դուք պետք է իրականացնեք հետևյալ մեթոդներըկյանքի ցիկլ:

Համակարգն անվանում է այս մեթոդը, երբ այն ստեղծում է հատված: Իր իրականացման ընթացքում նախագծողը պետք է սկզբնավորի հատվածի հիմնական բաղադրիչները, որոնք պետք է պահպանվեն, երբ հատվածը դադարեցվի կամ վերսկսվի դադարեցվելուց հետո: Համակարգը կանչում է այս մեթոդը, երբ առաջին անգամ էկրանին ցուցադրվում է հատվածի միջերեսը: Հատվածի միջերեսը ցուցադրելու համար այս մեթոդը պետք է վերադարձնի այն օբյեկտը, որը հատվածի դասավորության արմատն է: Եթե ​​հատվածը չունի օգտատիրոջ միջերես, կարող եք վերադարձնել null: Համակարգն այս մեթոդն անվանում է որպես առաջին ցուցում, որ օգտագործողը թողնում է հատվածը (սա միշտ չէ, որ նշանակում է, որ հատվածը ոչնչացվում է): Սովորաբար սա այն ժամանակն է, երբ պետք է կատարվեն ցանկացած փոփոխություն, որը պետք է պահպանվի օգտագործողի ընթացիկ աշխատաշրջանից դուրս (քանի որ օգտվողը կարող է չկարողանալ հետ գնալ):

Կան նաև մի շարք ենթադասեր, որոնք կարող են անհրաժեշտ լինել ընդլայնել բազային դասի օգտագործման փոխարեն.

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

Օգտագործողի միջերեսի ավելացում

Հատվածը սովորաբար օգտագործվում է որպես գործունեության օգտատիրոջ միջերեսի մաս և ավելացնում է իր սեփական դասավորությունը գործունեությանը:

Հատվածի համար դասավորություն ստեղծելու համար մշակողը պետք է կիրառի հետադարձ զանգի մեթոդ, որը Android համակարգԿանչվում է, երբ ժամանակն է, որ հատվածը ներկայացնի իր դասավորությունը: Այս մեթոդի իրականացումը պետք է վերադարձնի օբյեկտ, որը հատվածի դասավորության արմատն է:

Նշում.Եթե ​​հատվածը դասի ենթադաս է, ապա լռելյայն իրականացումը վերադարձնում է դասը մեթոդից, ուստի այն իրականացնելու կարիք չկա։

Մեթոդից դասավորությունը վերադարձնելու համար այն կարող եք ուռճացնել XML ֆայլում սահմանված մեթոդից: Այդ նպատակով մեթոդը ապահովում է.

Օրինակ, դասի ենթադասերի կոդը, որը բեռնում է դասավորությունը example_fragment.xml-ից, կարող է այսպիսի տեսք ունենալ.

Հանրային ստատիկ դասը ExampleFragment ընդլայնում է Fragment ( @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) ( // Inflate the layout for this fragment return inflater.inflate(R.layout.example), falsement);

Դասավորության ստեղծում

Ստորև բերված կոդում R.layout.example_fragment կոնստրուկցիան հղում է հավելվածի ռեսուրսներում պահվող օրինակ_fragment.xml անունով դասավորության ռեսուրսին: XML-ում դասավորության ստեղծման մանրամասների համար տե՛ս այս հոդվածը:

Գործողության օրինակի համար, որն օգտագործում է հատվածը որպես ֆոնային թեմա, առանց օգտատիրոջ միջերեսի, տես FragmentRetainInstance.java կոդի նմուշը, որը ներառված է SDK նմուշներում (և հասանելի է Android SDK կառավարչի միջոցով): Համակարգում դրան տանող ճանապարհն է /APIDemos/app/src/main/java/com/example/android/apis/app/FragmentRetainInstance.java:

Ֆրագմենտների կառավարում

Գործողության մեջ բեկորները կառավարելու համար ձեզ անհրաժեշտ է դաս: Այն ստանալու համար դուք պետք է զանգահարեք մեթոդը opcode-ից:

Ստորև ներկայացված են այն գործողությունները, որոնք դուք կարող եք կատարել.

• ստացեք գործողության մեջ առկա բեկորները՝ օգտագործելով մեթոդը (հատվածների համար, որոնք ապահովում են օգտագործողի ինտերֆեյսշահագործման դասավորության մեջ) կամ (օգտագործողի միջերեսով երկու հատվածների և առանց դրա հատվածների համար);
• հեռացնել բեկորները անցումների կույտից՝ օգտագործելով հետընթաց մեթոդը (կոճակ սեղմելը նմանակում է Ետօգտագործող);
• գրանցեք փոփոխության լսողի գործընթացը հետևի կույտում՝ օգտագործելով .

լրացուցիչ տեղեկությունԱյս և այլ մեթոդներ նկարագրված են դասի փաստաթղթերում:

Ինչպես ցույց է տրված նախորդ բաժնում, դուք կարող եք օգտագործել Open դասը, որը թույլ է տալիս գործարքներ կատարել ֆրագմենտների վրա, ինչպիսիք են՝ ավելացնելն ու ջնջելը:

Գործարքների կատարում բեկորներով

Գործողության մեջ ֆրագմենտների օգտագործման մեծ առավելությունն այն է, որ դրանք ավելացնելու, հեռացնելու, փոխարինելու և դրանցով այլ բաներ անելու ունակությունն է՝ ի պատասխան օգտագործողի մուտքի: Գործողության մեջ կատարված փոփոխությունների ցանկացած փաթեթ կոչվում է գործարք: Դա կարելի է անել՝ օգտագործելով API-ները: Յուրաքանչյուր գործարք կարող է պահվել հետին կույտում, որը կառավարվում է գործողության կողմից: Սա թույլ կտա օգտագործողին հետ շարժվել բեկորների փոփոխությունների միջոցով (նման է գործողությունների միջոցով հետ շարժվելուն):

Գործողության հետ փոխազդեցություն

հանրային ստատիկ FragmentA դասը ընդլայնում է ListFragment-ը ( OnArticleSelectedListener mListener; ... @Override public void onAttach (Գործունեության գործունեություն) ( super.onAttach (ակտիվություն); փորձել ( mListener = (OnArticleSelectedListener) գործունեություն; ) catch (ClassCastException) activity.toString() + "-ը պետք է իրականացնի OnArticleSelectedListener"); ) ) ... )

Եթե ​​գործողությունը չի իրականացրել ինտերֆեյսը, ապա հատվածը բացառություն է անում: Եթե ​​հաջողվի, mListener տարրը հղում կպարունակի OnArticleSelectedListener ինտերֆեյսի գործողության իրականացմանը, որպեսզի հատված A-ն կարողանա կիսել իրադարձությունները գործողության հետ՝ կանչելով OnArticleSelectedListener ինտերֆեյսի կողմից սահմանված մեթոդները: Օրինակ, եթե հատվածը A-ն դասի ընդլայնումն է, ապա ամեն անգամ, երբ օգտատերը սեղմում է ցանկի տարրի վրա, համակարգը կանչում է հատվածը: Այս մեթոդն իր հերթին կանչում է onArticleSelected() մեթոդը՝ իրադարձությունը գործողության հետ համատեղ օգտագործելու համար.

Հանրային ստատիկ FragmentA դասը ընդլայնում է ListFragment ( OnArticleSelectedListener mListener; ... @Override public void onListItemClick(ListView l, View v, int դիրք, long id) ( // Կտտացրած նյութի տողի ID-ն ավելացրեք բովանդակության մատակարարով Uri Uri noteUri = ContentUris.(ArticleColumns.CONTENT_URI, id); // Ուղարկեք իրադարձությունը և Uri-ն հյուրընկալող գործունեությանը mListener.onArticleSelected(noteUri); ) ... )

Մեթոդին փոխանցված id պարամետրը ցանկի ընտրված տարրը պարունակող տողի ID-ն է, որը գործողությունը (կամ այլ հատված) օգտագործում է հոդվածը հավելվածի օբյեկտից առբերելու համար:

Բովանդակության մատակարարի հետ աշխատելու մասին լրացուցիչ տեղեկությունների համար տե՛ս փաստաթուղթը:

Գործողությունների տողում տարրերի ավելացում

Հատվածները կարող են մենյուի տարրեր ավելացնել գործողություններին (և հետևաբար՝ ) իրականացնելով: Այնուամենայնիվ, որպեսզի այս մեթոդը զանգեր ընդունի, այն պետք է կանչվի գործարկման ժամանակ՝ նշելու, որ հատվածը մտադիր է տարրեր ավելացնել Ընտրանքների ցանկում (հակառակ դեպքում հատվածը չի ընդունի մեթոդի կանչը):

Ընտրանքների ընտրացանկում հատվածի կողմից ավելացված ցանկացած տարր ավելացվում է գոյություն ունեցողներին: Բացի այդ, հատվածը ստանում է մեթոդի հետադարձ զանգեր, երբ օգտագործողը ընտրում է ցանկի տարրը:

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

Նշում.Թեև ֆրագմենտը հետադարձ զանգ է ստանում «ընտրված ընտրացանկից» իրադարձության համար, որն ավելացնում է յուրաքանչյուր տարրի համար, գործունեությունը նախ ստանում է համապատասխան զանգը, երբ օգտագործողը ընտրում է ընտրացանկի տարրը: Եթե ​​մենյուի տարրի ընտրված իրադարձության համար գործող հետադարձ զանգի իրականացումը չի մշակում ընտրված տարրը, իրադարձությունը փոխանցվում է հատվածի հետադարձ զանգի մեթոդին: Սա ճիշտ է Ընտրացանկերի և համատեքստի ընտրացանկերի համար:

Մենյուի մանրամասն տեղեկությունների համար տե՛ս մշակողի ուղեցույցները և

Հատված կյանքի ցիկլի կառավարում

Նկար 3. Գործողության կյանքի ցիկլի ազդեցությունը կյանքի ցիկլհատված

Հատվածի կյանքի ցիկլի կառավարումը շատ առումներով նման է գործողության կյանքի ցիկլի կառավարմանը: Գործողության նման, հատվածը կարող է գոյություն ունենալ երեք վիճակներից մեկում.

Վերսկսվել էՎիրահատության ընթացքում բեկորը տեսանելի է։ Կասեցվել էԳործում է մեկ այլ գործողություն և կենտրոնացված է առաջին պլանում, սակայն հատվածը պարունակող գործունեությունը դեռ տեսանելի է (առաջին պլանի գործունեությունը մասամբ թափանցիկ է կամ չի լրացնում ամբողջ էկրանը): ԴադարեցվեցԿտորը տեսանելի չէ։ Կամ կոնտեյների աշխատանքը դադարեցվել է, կամ հատվածը հեռացվել է դրանից, բայց ավելացվել է հետևի կույտին: Կասեցված հատվածը դեռ ակտիվ է ( վիճակի և տարրերի մասին բոլոր տեղեկությունները պահվում են համակարգում): Այնուամենայնիվ, այն այլևս տեսանելի չէ օգտագործողի համար և կկործանվի, եթե գործողությունը ոչնչացվի:

Այստեղ կրկին տեսանելի է անալոգիան գործողության հետ. մշակողը կարող է օգնությամբ պահպանել ֆրագմենտի վիճակը, եթե գործառնական պրոցեսը ոչնչացվի, և մշակողը պետք է վերականգնի հատվածի վիճակը, երբ գործողությունը վերստեղծվի: Վիճակը կարող է պահպանվել բեկորում հետադարձ զանգի մեթոդի կատարման ժամանակ և վերականգնվել , կամ . Համառության մասին լրացուցիչ տեղեկությունների համար տե՛ս փաստաթուղթը:

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

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

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

Համապատասխանեցում գործունեության կյանքի ցիկլի հետ

Ֆրագմենտը պարունակող ակտիվության կյանքի ցիկլը ուղղակիորեն ազդում է հատվածի կյանքի ցիկլի վրա, այնպես որ յուրաքանչյուր գործունեության կյանքի ցիկլի հետ կանչը հանգեցնում է նույնանման հետ կանչի յուրաքանչյուր հատվածի համար: Օրինակ, երբ գործողությունն ընդունում է զանգ, դրա յուրաքանչյուր հատված ընդունում է .

Այնուամենայնիվ, ֆրագմենտներն ունեն մի քանի լրացուցիչ կյանքի ցիկլի հետ կանչելու մեթոդներ, որոնք ապահովում են եզակի փոխազդեցություն գործողության հետ՝ իրականացնելու այնպիսի գործողություններ, ինչպիսիք են հատվածի միջերեսի ստեղծումն ու ոչնչացումը: Սրանք մեթոդներն են.

OnCreate() , այս գործողության մեջ գտնվող հատվածը պարզապես ընդունում է հետ կանչելու մեթոդ:

Երբ գործողությունը մտնում է «վերսկսված» վիճակ, դուք կարող եք ազատորեն դրան ավելացնել և հեռացնել բեկորներ: Այսպիսով, հատվածի կյանքի ցիկլը կարող է ինքնուրույն փոփոխվել միայն այն ժամանակ, երբ գործողությունը մնում է «վերսկսված» վիճակում:

Այնուամենայնիվ, երբ վիրահատությունը դուրս է գալիս այս վիճակից, բեկորի առաջընթացն իր կյանքի ցիկլով կրկին իրականացվում է վիրահատության միջոցով:

Օրինակ:

Այս փաստաթղթում ընդգրկված ամեն ինչ ամփոփելու համար եկեք դիտարկենք գործողության օրինակ, որն օգտագործում է երկու հատված՝ երկու վահանակից բաղկացած դասավորություն ստեղծելու համար: Ստորև բերված գործողությունը ներառում է մեկ հատված՝ ցուցադրելու Շեքսպիրի պիեսների ցանկը, և մյուսը՝ ցուցադրելու ցանկից ընտրված պիեսի ամփոփումը: Օրինակը ցույց է տալիս, թե ինչպես պետք է կազմակերպվեն բեկորների տարբեր կոնֆիգուրացիաներ՝ կախված էկրանի կազմաձևից:

Նշում.Այս գործողության ամբողջական սկզբնական կոդը գտնվում է բաժնում:

Հիմնական գործողությունը կիրառում է դասավորությունը սովորական ձևով, մեթոդով.

@Override պաշտպանված void onCreate (Փաթեթ savedInstanceState) ( super.onCreate (savedInstanceState); setContentView (R.layout.fragment_layout); )

Fragment_layout.xml դասավորությունը օգտագործվում է այստեղ.

Օգտագործելով այս դասավորությունը, համակարգը ստեղծում է TitlesFragment դասի օրինակ (պիեսների ցանկ), հենց որ գործողությունը բեռնում է դասավորությունը: Այս դեպքում օբյեկտը (որը կպարունակի հատված ամփոփմամբ) տեղ է զբաղեցնում էկրանի աջ կողմում, բայց սկզբում դատարկ է մնում։ Ինչպես կցուցադրվի ստորև, հատվածը չի տեղադրվում, քանի դեռ օգտատերը չի ընտրել որևէ կետ ցանկում:

Այնուամենայնիվ, ոչ բոլոր էկրաններն են բավականաչափ լայն՝ տեսացանկի կողքին ամփոփում ցուցադրելու համար: Հետևաբար, վերը նկարագրված դասավորությունը օգտագործվում է միայն լանդշաֆտային էկրանի կողմնորոշման մեջ և պահվում է res/layout-land/fragment_layout.xml ֆայլում։

Երբ սարքը միացված է դիմանկարային կողմնորոշում, համակարգը կիրառում է ստորև ներկայացված դասավորությունը, որը պահվում է res/layout/fragment_layout.xml ֆայլում:

Այս դասավորության մեջ առկա է միայն TitlesFragment օբյեկտը: Սա նշանակում է, որ երբ սարքը գտնվում է դիմանկարային կողմնորոշման մեջ, տեսանելի է միայն պիեսների ցանկը: Երբ օգտատերը կտտացնում է այս կոնֆիգուրացիայի ցանկի տարրը, հավելվածը սկսում է նոր գործունեություն՝ ցուցադրելու ամփոփումը, այլ ոչ թե երկրորդ հատվածը բեռնելու համար:

Հաջորդը կարող եք տեսնել, թե ինչպես է դա իրականացվում հատվածների դասերում: Սկզբում գալիս է TitlesFragment դասի կոդը, որը ցուցադրում է Շեքսպիրի պիեսների ցանկը: Այս հատվածը ընդլայնում է դասը և օգտագործում է իր գործառույթները ցուցակի հետ հիմնական աշխատանքը կատարելու համար:

Երբ դուք ուսումնասիրում եք կոդը, նկատեք, որ կա երկու հնարավոր վարքագիծ՝ ի պատասխան այն բանի, որ օգտվողը սեղմում է ցանկի տարրը: Կախված նրանից, թե երկու դասավորություններից որն է ակտիվ, կա՛մ մեկ գործողություն է ստեղծում և ցուցադրում նոր ամփոփ հատված (հատվածն օբյեկտին ավելացնելով), կա՛մ գործարկվում է նոր գործունեություն (հատվածի ցուցադրում):

Երկրորդ հատվածը՝ DetailsFragment, ցուցադրում է TitlesFragment ցանկում ընտրված պիեսի ամփոփագիրը.

Եկեք հիշենք TitlesFragment դասի կոդը. եթե օգտագործողը սեղմում է ցանկի տարրը, և ընթացիկ դասավորությունը Ոչներառում է R.id.details տեսքը (որին պատկանում է DetailsFragment), ապա հավելվածը գործարկում է DetailsActivity՝ տարրի բովանդակությունը ցուցադրելու համար:

Հանրային ստատիկ դասի DetailsActivity ընդլայնում է Activity ( @Override protected void onCreate(Bundle savedInstanceState) ( super.onCreate(savedInstanceState); if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) (հիմա // Եթե էկրանը գտնվում է // լանդշաֆտային ռեժիմ, մենք կարող ենք ցուցադրել // երկխոսությունը ցուցակի հետ, այնպես որ մեզ պետք չէ այս գործողությունը: finish(); return; ) if (savedInstanceState == null) ( // Նախնական տեղադրման ժամանակ միացրեք մանրամասները fragment.DetailsFragment մանրամասներ = նոր DetailsFragment(); details.setArguments(getIntent().getExtras());getFragmentManager().beginTransaction().add(android.R.id.content, details).commit(); ) ) )

Նկատի ունեցեք, որ լանդշաֆտային կազմաձևում այս գործողությունն ինքնին ավարտվում է, որպեսզի հիմնական գործունեությունը կարողանա վերահսկել և ցուցադրել DetailsFragment-ը TitlesFragment-ի կողքին: Դա կարող է տեղի ունենալ, եթե օգտատերը սկսի DetailsActivity-ը էկրանի դիմանկարային կողմնորոշմամբ և այնուհետև սարքը շրջի դեպի լանդշաֆտային կողմնորոշում (որ արդյունքում ընթացիկ գործունեությունը վերսկսվում է):

Կոդի լրացուցիչ նմուշներ՝ օգտագործելով հատվածներ (և ամբողջական ֆայլեր) աղբյուր կոդըայս օրինակը) հասանելի են Demos API-ի նմուշի հավելվածում (որը կարելի է ներբեռնել ից):

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

Rake Activity

Android-ի մշակման հնարքները ցուցադրող ձեռնարկների մեծ մասը սկսվում է նույն կերպ. անփորձ ծրագրավորողներին խնդրում են նետել բոլոր տեսողական տարրերն անմիջապես հիմնական Գործունեության XML նշագրման մեջ: Դա նման բան է թվում.

Հանրային դասի MainActivity-ն ընդլայնում է AppCompatActivity-ը ( @Override պաշտպանված void onCreate(Bundle savedInstanceState) ( super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); ...

Նման ձևավորումը դառնում է սովորություն, և նախագիծը լցվում է նոր Գործողություններով՝ գնալով ավելի բարդ նշագրումներով: Արդյունքում՝ նույնիսկ նվազագույն օգտակար հավելվածդառնում է գերաճած Գործունեության կույտով՝ կուլ տալով բոլորը RAM, և Google Play-ում ծրագրավորողի վրա քարեր ու դեյուներ են թռչում:

Եվ ամեն ինչ, քանի որ Android ՕՀ-ն չի խոստանում կենդանի պահել ձեր Գործունեությունը: Ինչպես հիշում եք, այս բաղադրիչները գոյություն ունեն միմյանցից անկախ՝ ունենալով կյանքի հատուկ ցիկլ։ Եթե ​​Activity-ն անցնում է դադարի վիճակի, և դա տեղի է ունենում բավականին հաճախ, այն դառնում է Շրյոդինգերի կատուն. դուք չեք կարող նախապես իմանալ՝ նա կենդանի կլինի, թե ոչ:

Օգտագործելով լրացուցիչ Գործունեություններ՝ մենյուները և այլ մանրուքներ ցուցադրելու համար՝ դուք վտանգի տակ եք դնում հավելվածի բոլոր տրամաբանական կապերը: Գործողությունները հավաքվում են կույտի վրա, և ՕՀ-ն կարող է սկսել դրանք մեկ առ մեկ կամ խմբով բեռնաթափել: Երբ օգտատերը ցանկանում է վերադառնալ նախորդ պատուհան, Գործունեությունը կարող է արդեն ոչնչացվել, և օգտատերը դուրս կգա հավելվածից:

Ի լրումն տրամաբանության պահպանման հետ կապված խնդիրների, կա նաև OOP կոդի աջակցման ռեժիմ. Գործունեության հետ սերտորեն կապված ինտերֆեյսները գրեթե անհնարին են հետագա զարգացումը: Սանդղակավորում, արագ փոխարինումորոշ տարրեր մյուսներին, անիմացիա - այս ամենը շատ դժվար կլինի իրականացնել հավելվածի նոր տարբերակներում:

Մեկ էկոհամակարգի նորաձևության շնորհիվ՝ ամեն ինչ բջջային հավելվածներընդհանուր առմամբ շատ նման էին: Պարզապես պետք է գտնել ճանապարհը և մի փոքր պարապել, իսկ հետո որակը սկսում է արագ աճել։ Հետևելով «քննադատել-առաջարկել» սկզբունքին, այժմ մենք կգրենք հավելված, որն իրականացնում է օգտատիրոջ ունիվերսալ միջերես: Սա հետաքրքիր կլինի ոչ միայն ակադեմիական տեսանկյունից. վստահ եմ, որ դուք կարող եք հեշտությամբ ինտեգրել այսօր գրված կոդը ձեր նախագծերում: Այսպիսով, եկեք սկսենք:

Բեկորներ

UI-ի հետ աշխատելն ավելի հեշտ և արագ դարձնելու համար Google-ը ստեղծեց «Fragment»՝ դաս, շերտ՝ ծրագրի գործունեության և տեսողական բաղադրիչների միջև: Մի կողմից, դա կոնտեյներ է ցանկացած View օբյեկտի համար, որը կարող է ցուցադրվել օգտագործողին: Մյուս կողմից, կա Գործունեության շարունակություն, որից Fragment-ը ստանում է ողջ տեղեկատվությունը կյանքի ցիկլի փոփոխությունների մասին:

Հատվածները, ինչպես Activity-ն, ունեն իրենց սեփական (թեև ավելի օրիգինալ) կյանքի ցիկլը: Օրինակ, ֆրագմենտի ստեղծումից անմիջապես հետո անհնար է աշխատել UI-ի հետ, դուք պետք է սպասեք, որ բոլոր տարրերը բեռնվեն. onCreate մեթոդից հետո կկատարվի onCreateView մեթոդը, որտեղ կարող են բեռնվել տարրերը:

Հանրային դասի FragmentOne-ն ընդլայնում է Fragment-ը ( ... public View onCreateView(...) ( Դիտել տեսքը=inflater.inflate(R.layout.fragment_one, կոնտեյներ,կեղծ); TextView textView = (TextView)view.findViewById(R.id.fo_text); textView.setText ("Բարև, ես առաջին հատվածն եմ!"); վերադարձի տեսք; ...

Հատվածում կարող եք նաև անտեսել ցանկացած մեթոդ, որը վերահսկում է պատուհանի վիճակը: Այսպիսով, եթե հավելվածը մտնի հետին պլան, ապա Activity-ում կկատարվի onPause, այնուհետև այստեղ կկատարվի ճիշտ նույն անունով մեթոդը: Սա կարող է օգտակար լինել. հարմար է երրորդ կողմի օբյեկտներից անջատվելու համար, ինչպիսիք են կապված ծառայությունները:

FragmentTransaction

Իմանալով, որ բեկորների հետ աշխատելն ինտենսիվ է լինելու, Google-ը դրա համար նախապես հատուկ գործիքներ է ստեղծել: FragmentManager և FragmentTransaction դասերը կուտակում են բոլոր գործընթացները՝ ստեղծելով նոր բեկորներ և ջնջելով դրանք, տվյալների փոխանցում և այլն։

FragmentManager օբյեկտ ստեղծելու կարիք չկա, այն արդեն կա յուրաքանչյուր Activity-ում, պարզապես պետք է դրա հղումը ստանալ: Եվ բոլոր գործողությունները կանցնեն FragmentTransaction-ի միջոցով, որն այնուհետև ինքնուրույն տվյալներ կփոխանցի հատվածի կառավարիչին:

FragmentManager մենեջեր = getSupportFragmentManager(); FragmentTransaction գործարք = manager.beginTransaction();

Կցանկանայի նշել, որ ֆրագմենտներով աշխատող դասերը հասանելի են երկու տարբերակով։ Ես խորհուրդ եմ տալիս օգտագործել ավելի նոր տարբերակ. սրանք այն տարբերակներն են, որոնց ներմուծման ճանապարհին կա android.support.v4 տողը: Սա մեծ գրադարան է, որը ստեղծված է հետամնաց համատեղելիության համար: Google ընկերությունՍարքերին խնամքով է վերաբերվում ՕՀ-ի բոլոր տարբերակներին, իսկ գրադարանները թույլ են տալիս օգտագործել զարգացման նորարարությունները նույնիսկ հին API-ի հետ աշխատելիս:

Ներմուծեք android.support.v4.app.FragmentTransaction; ներմուծել android.support.v4.app.Fragment;...

FrameLayout

Հաճախ UI-ի տվյալները գալիս են դինամիկ կերպով՝ կախված ընթացիկ իրադարձություններից: Նկար կամ տեքստ տեղադրելու տեղ ունենալու համար կա հատուկ կոնտեյներ՝ FrameLayout: Սա նրա հիմնական խնդիրն է՝ էկրանին տարածք վերապահել View դասի ցանկացած օբյեկտի համար, որը կարող է բեռնվել ավելի ուշ։ Այդպիսի տարաներում ապրում են նաև բեկորներ։

Դուք կարող եք նոր հատված ավելացնել FrameLayout-ին տարբեր ձևերով. FragmentTransaction-ն ունի նմանատիպ գործառույթներ՝ փոխարինելու և ավելացնելու մեթոդներ:

Transaction.replace(R.id.frame_container, fragmentObject);

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

Transaction.add(R.id.frame_container, fragment);

Ավելացնել մեթոդը ստեղծում է բեկորների կույտ, և յուրաքանչյուրը նոր մարտահրավերհրում է նոր օրինակ բուրգի վերին մասում: Կարևոր է, որ երբ հայտնվում է նոր բեկոր, դարակի հին օբյեկտները չեն ստանում ծանուցումներ և գործում են այնպես, կարծես ոչինչ չի եղել: Սա նշանակում է, որ նրանց համար onPause մեթոդը չի գործարկվի, և նրանք կշարունակեն սպառել սարքի ռեսուրսները, թեև օգտվողն այլևս չի տեսնի դրանք:

Բաշխված հիշողության նման վատնումը կարող է արդարացված լինել, օրինակ, եթե ցանկանում եք կազմակերպել տվյալների նախնական մշակումը. հատվածը կարող է ինչ-որ բան բեռնել, մինչդեռ այն անտեսանելի է, և հետո ցույց տալ ավարտված արդյունքը:

Կարող են լինել մի քանի գործողություններ բեկորներով, դրանք կկուտակվեն այնքան ժամանակ, մինչև կատարվի commit մեթոդը:

Transaction.commit();

Շարունակությունը հասանելի է միայն անդամներին

Տարբերակ 1. Միացեք «կայքի» համայնքին՝ կայքի բոլոր նյութերը կարդալու համար

Նշված ժամանակահատվածում համայնքին անդամակցությունը ձեզ հնարավորություն կտա մուտք գործել ԲՈԼՈՐ Հաքերային նյութերը, կավելացնի ձեր անձնական կուտակային զեղչը և թույլ կտա ձեզ կուտակել պրոֆեսիոնալ Xakep Score վարկանիշ:

Ընդհանուր հասկանալու համար ես նաև որոշեցի ուսումնասիրել ֆրագմենտի կյանքի ցիկլը գործունեության ցիկլի հետ համատեղ, որը տեղի է ունենում, երբ գործարկվում և ոչնչացվում է բեկորով գործունեությունը: Արդյունքը հետևյալն է.

Գաղտնի հատվածների մեթոդների ցանկը

Երեք հիմնական մեթոդ, որոնք օգտագործվում են գրեթե ցանկացած կիրառման մեջ.

onCreate— ֆրագմենտի ներքին բաղադրիչների սկզբնավորումը պահպանված տվյալներով։

onCreateView- ցուցադրման համար բաղադրիչի ստեղծում:

միացնել Դադարը— կարգավորել իրավիճակը, երբ հատվածը կորցնում է ուշադրությունը:

Բոլոր մեթոդների նկարագրությունը այն հերթականությամբ, որը կոչվում է.

վրաԿցել— հատվածի առաջին միացումը գործունեությանը: Այն գործունեությունը, որին կապ է հաստատվում, փոխանցվում է այստեղ։

onCreate- հատվածի սկզբնավորում: Bundle դասի տվյալներն իր նախորդ կյանքում ֆրագմենտի վերջին վիճակի մասին, եթե եղել է, ավելի վաղ պահված, օրինակ՝ onSaveInstanceState մեթոդով, փոխանցվում են այստեղ՝ այս վիճակը վերականգնելու համար: Այս պահին գործունեությունը դեռ ստեղծման փուլում է։

onCreateԴիտել - ցուցադրման համար տեսարանի ձևավորում: Վերադարձնում է հատվածի տեսքը: Կարող է վերադառնալդատարկ ոչ տեսողական բաղադրիչների համար: Այստեղ փոխանցվում են Bundle դասի տվյալները հատվածի վերջին վիճակի մասին, ինչպես նաև ակտիվության կոնտեյները, որտեղ կմիացվեն հատվածը և նշագրման «փչիչը»:

վրաԴիտելՍտեղծելդ -Կանչվում է, երբ տեսքը ձևավորվում է: Ստեղծված տեսքը և բեկորի վերջին վիճակի մասին Bundle դասի տվյալները փոխանցվում են այստեղ: Օգտագործվում է տեսքը վերջնական տեսքի բերելու համար, նախքան պահպանված վիճակը վերականգնելը: Այս պահին տեսարանը դեռ կցված չէ հատվածին:

onActivityCreateդ - վերջնական սկզբնավորում. Կանչվում է, երբ գործունեության onCreate() մեթոդը վերադառնում է: Գործունեությունը ստեղծվում է, հատվածը տեղադրվում է դրա մեջ: Օգտագործվում է, օրինակ, հատվածի վիճակը վերականգնելու համար։ Փաթեթի վերջին վիճակի մասին Bundle դասի տվյալները փոխանցվում են այստեղ:

onViewStateRestored — դիտման սկզբնավորումը՝ հիմնված պահպանված վիճակի վրա: Կանչվում է, երբ դիտման պահպանված վիճակը վերականգնվում է:

onSaveInstanceState— պահպանելով հատվածի վիճակը: Այն աշխատում է միայն այն դեպքում, եթե բեկորը դադարում է և կարող է ոչնչացվել համակարգի կողմից, բայց իրականում դեռ անհրաժեշտ է: Դա տեղի է ունենում, օրինակ, երբ կանչվում է հաջորդ գործողությունը, երբ սեղմվում է գլխավոր կոճակը, ինչպես նաև սարքի կազմաձևման փոփոխության հետևանքով գործունեության ամբողջական ոչնչացման և դրա նոր ստեղծման դեպքում (լեզվի փոփոխություն , մուտքային սարք, էկրանի կողմնորոշում և այլն): Bundle դասի օբյեկտը, որը պահպանում է ակտիվության վիճակը, փոխանցվում է onCreate, onPostCreate և onRestoreInstanceState մեթոդներին։ Ուշադրություն. Մեթոդը կարելի է զանգահարել նախկինում ցանկացած ժամանակ onDestroy!

վրաDestroyView— Կոչվում է, երբ տեսարանն անջատված է հատվածից: Հաջորդ անգամ, երբ հատվածը կցուցադրվի, նոր տեսք կստեղծվի:

onԱնջատել- Զանգել է մինչև բեկորը գործունեությունից անջատելը։

Վերջին թարմացումը՝ 10/30/2015

Յուրաքանչյուր բեկորային դաս ժառանգում է Fragment բազային դասը և ունի իր կյանքի ցիկլը, որը բաղկացած է մի շարք փուլերից.

onAttach() . Երբ այս մեթոդը գործարկվում է, հատվածը կապված է որոշակի գործունեության հետ: Այս պահին հատվածը և ակտիվությունը դեռ ամբողջությամբ չեն սկզբնավորվել:

onCreate()՝ հատվածը ստեղծվում է: Այս մեթոդը կանչվում է ակտիվության համապատասխան onCreate() մեթոդը կանչելուց հետո։

onCreateView()՝ հատվածը ստեղծում է տեսողական ինտերֆեյս

onActivityCreated()՝ կանչվում է գործունեությունը ստեղծելուց հետո: Այսուհետ ինտերֆեյսի բաղադրիչները հասանելի են findViewById() մեթոդի միջոցով

onStart()՝ կանչվում է, երբ հատվածը տեսանելի է դառնում

onResume()՝ հատվածն ակտիվանում է

onPause()՝ հատվածը մնում է տեսանելի, բայց այլևս ակտիվ չէ

onStop()՝ հատվածն այլևս տեսանելի չէ

onDestroyView()՝ հատվածը ներկայացնող ինտերֆեյսը ոչնչացված է

onDestroy()՝ հատվածի մշտական ​​ոչնչացում

Հատված դասի կոդում մենք կարող ենք վերացնել այս բոլոր մեթոդները կամ դրանցից մի քանիսը:

Քանի որ ֆրագմենտները հաճախ օգտագործվում են որոշակի նպատակների համար, օրինակ՝ որոշ օբյեկտների ցուցակ ցուցադրելու համար, լռելյայն մենք մուտք ունենք Fragment-ից ստացված դասեր, որոնք արդեն ունեն որոշակի հնարավորություններ.

ListFragment. կառավարում է տարրերի ցանկը՝ օգտագործելով ադապտերներից մեկը

DialogFragment. օգտագործվում է երկխոսության տուփեր ստեղծելու համար

PreferenceFragment. օգտագործվում է հավելվածի նախապատվությունները կառավարելու համար

Դուք կարող եք օգտագործել սովորական դասեր՝ նոր հատված ստեղծելու համար: Այնուամենայնիվ, շրջակա միջավայրը Android Studioարդեն առաջարկում է մի շարք ներկառուցված կաղապարներ.

Ստեղծելիս ձեզանից կպահանջվի սահմանել նախագծի անվանումը, ինտերֆեյսի նշագրման ֆայլի անվանումը և մի շարք այլ տարբերակներ.

Android Studio-ի կողմից ստեղծված հատվածի դասը հիմնականում նման կլինի նախկինում օգտագործվածներին.

Փաթեթ com.example.eugene.testapp; ներմուծել android.app.Activity; ներմուծել android.net.Uri; ներմուծել android.os.Bundle; ներմուծել android.app.Fragment; ներմուծել android.view.LayoutInflater; ներմուծել android.view.View; ներմուծել android.view.ViewGroup; հանրային դասի BlankFragment ընդլայնում է Fragment ( մասնավոր ստատիկ վերջնական տող ARG_PARAM1 = «param1»; մասնավոր ստատիկ վերջնական տող ARG_PARAM2 = «param2»; մասնավոր տող mParam1; մասնավոր տող mParam2; մասնավոր OnFragmentInteractionListener mListener; Տող param1, String param2) ( BlankFragment fragment = new BlankFragment(); Bundle args = new Bundle(); args.putString(ARG_PARAM1, param1); args.putString(ARG_PARAM2, param2); fragment.setArguments(args); վերադարձի հատված ;) հանրային BlankFragment() ( // Կառուցիչ ) @Override public void onCreate(Bundle savedInstanceState) ( super.onCreate(savedInstanceState); if (getArguments() != null) (mParam1 = getArguments().getString(m2Param); = getArguments().getString(ARG_PARAM2); ) ) @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) ( return inflater.inflate(R.layout.fragment_blank, container, false); ) public void onButtonPressed(Uri uri) ( if (mListener != null) ( mListener.onFragmentInteraction(uri); ) ) @Override public void onAttach(Գործունեության գործունեություն) ( super.onAttach(activity); փորձեք ( mListener = (OnFragmentListener) գործունեություն; ) catch (ClassCastException ե) ( նետել նոր ClassCastException(activity.toString() + " պետք է իրականացնի OnFragmentInteractionListener"); ) ) @Override public void onDetach() ( super.onDetach(); mListener = null; ) հանրային ինտերֆեյսի OnFragmentListener ( Public void onFragmentInteraction (Uri uri); ) )

Հետևաբար, մենք կարող ենք ձեռքով ստեղծել դրվագներ կամ օգտագործել Android Studio-ի տրամադրած ձևանմուշներից մեկը։

Android-ի մշակման մասին խոսելիս անհնար է չհիշատակել բեկորներ.

Ինչ է Fragment-ը:

Fragment-ը ինտերֆեյսի հատուկ տարր է, որը նախատեսված է հեշտացնելու արձագանքող հավելվածների ստեղծումը, որոնք աշխատում են ինչպես սմարթֆոնների, այնպես էլ պլանշետների վրա:

Ֆրագմենտը պարունակում է ինտերֆեյսի տարրեր իր ներսում, ճիշտ ինչպես Գործունեությունը, այնուամենայնիվ, երկու հասկացությունների միջև կան մի քանի հիմնական տարբերություններ.

• Հատվածներսում պարունակվող Գործունեություն.
• Ներսում Գործունեությունկարող են լինել մի քանիսը բեկորներ, այսինքն՝ էկրանին կարող է միանգամից մի քանի բեկոր լինել, մինչդեռ Գործունեությունմիշտ մենակ ցանկացած պահի:

Հավելվածի իրականացում առանց բեկորների

Եկեք նայենք կոնկրետ օրինակավելի լավ հասկանալու համար, թե ինչպես է այն աշխատում:

Եկեք պատկերացնենք, որ մենք ունենք երկու էկրան պարունակող հավելված.

• Էկրան նորությունների հոսքով:
• Նորությունների մասին մանրամասներով էկրան է բացվում՝ սեղմելով նախորդ Գործունեության ցանկի տարրի վրա:

Ահա թե ինչ տեսք ունի հեռախոսի վրա.

Ստացվում է, որ մենք ունենք երկու Գործունեություն, որոնցից յուրաքանչյուրը պարունակում է որոշակի ինտերֆեյսի տարրեր։ Թող դրանք լինեն FeedActivity առաջին էկրանի համար և DetailActivity երկրորդ էկրանի համար:

Այժմ պատկերացրեք, որ մենք պետք է նաև հավելված պատրաստենք պլանշետի համար.

Այս դեպքում մենք ցուցադրում ենք բովանդակություն երկու էկրաններից մեկ էկրանին՝ օգտագործելով նույն տարրերը: Ստացվում է, որ մեզ անհրաժեշտ է երրորդ Activity, օրինակ՝ TabletFeedActivity։

Արդյո՞ք այս մոտեցումը կաշխատի: Այո՛։ Ճի՞շտ է։ Բացարձակապես ոչ:

Այս մոտեցումն օգտագործելիս մենք ոչ միայն ստեղծում ենք լրացուցիչ ավելորդ Ակտիվություն, այլև մենք զրկված ենք ծածկագիրը կրկին օգտագործելու հնարավորությունից. TabletFeedActivity-ի գրեթե ամբողջ կոդը պարզապես պատճենվելու է FeedActivity-ից և DetailActivity-ից:

Եվ ահա բեկորները մեզ օգնության են հասնում։

Հավելվածի իրականացում բեկորներով

Մենք թողնում ենք FeedActivity-ը և DetailActivity-ը, բայց ներկայացնում ենք երկու լրացուցիչ դասեր՝ FeedFragment ( Հատված թիվ 1ստորև նկարում) և DetailFragment ( Հատված թիվ 2ստորև նկարում):

Հեռախոս օգտագործելու դեպքում FeedFragment-ը գտնվում է FeedActivity-ում, իսկ DetailFragment-ը գտնվում է DetailActivity-ում՝

Եթե ​​հավելվածն աշխատում է պլանշետով, մենք երկու բեկորներն էլ ավելացնում ենք FeedActivity-ին, DetailActivity-ն ընդհանրապես չի օգտագործվում։ Բոլորը!

Այս կերպ մենք ավելորդ կոդ չենք գրում, և մեր հավելվածը դառնում է լիովին հարմարվողական։

Նույնը, ինչպես հետ Գործունեություն, յ հատվածգոյություն ունի կյանքի ցիկլ.

Հատվածը կարող է ունենալ երեք վիճակ.

• Դադարեցվեց- Էկրանի վրա բեկորը տեսանելի չէ: Այն գոյություն ունի, բայց հասանելի չէ օգտատերերի փոխազդեցության համար և կարող է ոչնչացվել, եթե դրա հետ կապված Գործունեությունը ոչնչացվի:
• Կասեցվել է- Հատվածը տեսանելի է էկրանին, բայց կարող է ծածկվել ինտերֆեյսի այլ տարրերով (օրինակ, առաջին պլանում կա մեկ այլ Գործունեություն):
• Վերսկսվել է- Հատվածը տեսանելի է էկրանին և հասանելի է օգտագործողին:

Նայեք բեկորների հետ կանչերի աղյուսակին, որոնք կանչվում են համապատասխանաբար, երբ Ակտիվության վիճակը փոխվում է.

Դիտարկենք դրանցից մի քանիսը:

• onAttach () - Հատված"կցվում է Գործունեություն.
• onCreate () - Հատվածստեղծվում է.
• onCreateView() - կոչ է արվում ստեղծել ինտերֆեյսի տարրեր (օրինակ՝ ինֆլեյ XML-ից):
• onActivityCreated() - կանչվում է onCreate() մեթոդի մշակումից հետո Գործունեություն.
• onDestroyView() - կանչվում է, երբ onCreateView-ում ստեղծված View-ը «անջատվում է» հատվածից:
• onDetach () - Հատված«անջատվում է». Գործունեություն.

Ընդհանուր առմամբ, ամեն ինչ շատ նման է Activity-ին, բացառությամբ որոշ նոր հետադարձ զանգերի:

Փորձենք սա գործնականում

Դրվագների ավելացում

Եկեք ստեղծենք մի ծրագիր, որը կունենա երկու հատված.

• Անջատիչներով հատված, որը մենք օգտագործում ենք գույն ընտրելու համար:
• Հատված պարզապես լցված ընտրված գույնով:

Հեռախոսում կլինի երկու էկրան. առաջինում մենք ընտրում ենք գույն, որից հետո Գործունեությունը գործարկվում է գույնը ցուցադրող հատվածով:

Պլանշետը կունենա միայն մեկ էկրան՝ երկու վահանակից բաղկացած ինտերֆեյսով, ճիշտ այնպես, ինչպես իմ վերը բերված օրինակում:

Նախ, եկեք պարզենք, թե ինչպես կարող ենք ստեղծել հատված և ավելացնել այն Activity-ում:

Ստեղծեք նոր նախագիծ, և դրա մեջ՝ նոր հատված.

Public class SelectionFragment-ը ընդլայնում է Fragment ( public SelectionFragment() ( ) @Nullable @Override public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup կոնտեյներ, Bundle savedInstanceState) ( return super.onCreateView(inflaterS), պարունակող կոնտեյներ

Նշում:Ֆրագմենտը պետք է ունենա կոնստրուկտոր առանց պարամետրերի, և չպետք է լինի այլ կոնստրուկտոր, քանի որ դրանք չեն կանչվի, երբ ֆրագմենտը վերստեղծվի:

Մենք նաև կստեղծենք ֆայլ՝ հատվածի դասավորությամբ՝ fragment_selection.xml:

Այժմ եկեք լրացնենք դասավորությունը onCreateView() մեթոդի ներսում.

@Nullable @Override public View onCreateView (LayoutInflater inflater, @Nullable ViewGroup բեռնարկղ, Bundle savedInstanceState) ( View view = inflater.inflate (R.layout.fragment_selection, բեռնարկղ, false); view.setBackgroundColor; )

Ես կարմիր գույնը դրեցի, որպեսզի պարզ լինի, թե որտեղ է գտնվում հատվածը:

Գործունեության մեջ հատված ավելացնելու երկու եղանակ կա.

• XML-ի միջոցով: Այս դեպքում հնարավոր չի լինի ջնջել հատվածը գործարկման ժամանակ:
• Գործարկման ժամանակ:

XML-ում հատվածի ավելացում

Փորձենք ավելացնել մի հատված activity_main.xml-ում:

Գործարկել հավելվածը.

Գործարկման ժամանակ հատվածի ավելացում

Նախ, եկեք փոխարինենք MainActivity դասավորության նշումը հետևյալով.

FrameLayout-ն այս դեպքում կծառայի որպես ֆրագմենտի կոնտեյներ:

Այժմ MainActivity-ում onCreate() մեթոդի վերջում ավելացրեք հետևյալ կոդը.

SelectionFragment selectionFragment = new SelectionFragment(); FragmentManager fragmentManager = getFragmentManager(); fragmentManager.beginTransaction() .add(R.id.container, selectionFragment) .commit();

Մենք ստեղծում ենք հատված, ստանում ենք ֆրագմենտ կառավարիչ և ավելացնում ենք ֆրագմենտը կոնտեյների մեջ։

FragmentManager-ը հատուկ դաս է, որի միջոցով տեղի է ունենում փոխազդեցություն բեկորների հետ:

Նշում: Android SDK-ում բեկորների երկու իրականացում կա. կանոնավորև սկսած Աջակցեք գրադարաններին v4. Չնայած ինտերնետի օրինակների մեծամասնությունը օգտագործում է Աջակցման գրադարանի իրականացումը, իրականում անհրաժեշտ չէ այն օգտագործել այս օրերին, քանի որ այն ստեղծվել է, որպեսզի բեկորները ավելի շատ աշխատեն: ավելի վաղ տարբերակները Android, քան 3.0.

3.0-ից դուք կարող եք օգտագործել կանոնավոր իրականացումը:

Երբ գործարկեք հավելվածը, կտեսնեք, որ արդյունքը մնում է նույնը.

Երկու վահանակի դասավորության ստեղծում

Այսպիսով, MainActivity-ի համար մեզ անհրաժեշտ կլինի երկու դասավորություն՝ մեկը՝ համար հեռախոսներ, երկրորդ համար հաբեր.

Եկեք ստեղծենք դասավորություն համար դեղահատ. Սա արվում է նույն կերպ, ինչպես սովորաբար՝ մեկ տարբերությամբ.

Ինչպես տեսնում եք, ես ընտրել եմ որակավորումը Էկրանի ամենափոքր լայնությունըև մուտքագրել է 600 արժեքը։ Այսպիսով, այս դասավորությունը կօգտագործվի միայն այն սարքերում, որոնց էկրանի լայնությունը առնվազն 600dp է: Սա մոտավորապես համապատասխանում է 7 դյույմանոց էկրանի անկյունագծով պլանշետին:

Ստանդարտ դասավորություն (համար հեռախոսներ) կլինի այսպես.

Քանի որ Android-ը խրախուսում է լինել հնարավորինս դեկլարատիվ միջերեսներ ստեղծելիս, և քանի որ մենք կարիք չենք ունենա հեռացնել կամ փոխարինել SelectionFragment-ը, մենք այն ուղղակիորեն կհայտարարենք XML-ում:

Դասավորությունը նախատեսված է հաբերկլինի այսպես.

Այստեղ մենք օգտագործում ենք SelectionFragment-ը ճիշտ նույն կերպ, սակայն այն չի զբաղեցնում ամբողջ էկրանը, այլ միայն երրորդը և, ի լրումն, մենք ավելացրել ենք կոնտեյներ երկրորդ հատվածի համար. չի աշխատի.

Քանի որ մենք այլևս դինամիկ կերպով չենք ավելացնում SelectionFragment-ը, հեռացրեք բոլոր առնչվող կոդը onCreate()-ից MainActivity-ում:

Նաև ստեղծեք նոր էմուլատոր պլանշետի համար, օրինակ, այսպես.

Գործարկեք հավելվածը դրա վրա.

Ինչպես տեսնում եք, պլանշետի վրա SelectionFragment-ը զբաղեցնում է էկրանի ձախ 30%-ը: Մնացած տարածքը վերապահված է երկրորդ հատվածի համար, որը դեռ հասանելի չէ։

Շարունակենք ավելացնելով ռադիո կոճակներ՝ գույներն ընտրելու համար:

RadioButton և RadioGroup

RadioButton - ռադիո կոճակներ ստեղծելու բաղադրիչ: Քանի որ RadioButton-ը չպետք է օգտագործվի միայնակ, դրա համար կա նաև դասավորություն՝ RadioGroup:

RadioGroup-ը ժառանգված է LinearLayout-ից և պարունակում է մի քանի RadioButtons: Այն վերահսկում է ընտրության բացառիկությունը (ի վերջո, ժամանակի մեկ միավորի համար կարող է ընտրվել միայն մեկ ռադիո կոճակ): LinearLayout-ից ժառանգության շնորհիվ այն կարող է լինել ինչպես ուղղահայաց, այնպես էլ հորիզոնական:

Շարունակությունը հասանելի է վճարովի պլանների վրա

Եվ դրա հետ մեկտեղ՝ մեր դաստիարակների կողմից տնային աշխատանքների ստուգումը:

Դա շատ էժան է 0 ₽ ամսական!