Собствени компоненти

Android предоставя сложен и мощен компонентен модел за изграждане на интерфейса на вашите приложения въз основа на основните класове за маркиране: View и ViewGroup. За бърз старт платформата включва стандартни компоненти, които са подкласове на View и ViewGroup - съответно джаджи и маркировка - които можете да използвате за създаване на потребителския интерфейс на вашите приложения.

Списъкът с приспособления включва бутони (Бутон), текстови полета (TextView), полета за въвеждане (EditText), списъци (ListView), квадратчета за отметка (CheckBox), радиобутони (RadioButton) и много други, в частност, специални джаджи AutoCompleteTextView. и TextSwitcher.

Сред компонентите за маркиране са LinearLayout, FrameLayout, RelativeLayout и други. За повече подробности вижте Markup.

Ако стандартните компоненти не могат да разрешат проблема ви, можете да създадете свои собствени подкласове View. Ако трябва само леко да промените характеристиките на съществуващите компоненти, можете просто да създадете подклас на съответния компонент и да замените неговите методи.

Изгледът за подкласиране ви дава фин контрол върху външния вид и функционалността на елемент. Ето няколко примера за компоненти, които можете да създадете:

Можете да създадете напълно персонализируем компонент за „контрол на силата на звука“, използвайки 2D графика, за да изглежда като аналогово електронно устройство.
Можете да поставите група визуални компоненти в нов компонент, може би чрез създаване на нещо като падащо меню, селектор с два панела (със списъци вляво и вдясно, чиито елементи могат да бъдат използвани повторно).
Можете да замените начина, по който компонентът EditText се показва на екрана (демонстрацията на Notepad използва приятен ефект за създаване на нарисувана страница).
Можете да заснемете всяко събитие, като натискане на клавиш или да извършвате действия по всякакъв начин (например в игри).

В следващия параграф ще разгледаме как да създадете персонализирани изгледи и да ги използвате във вашите приложения. За подробности вижте също Преглед на описанието на класа.

Основни неща

Ето описание на високо ниво за това, което трябва да направите, за да започнете да създавате свой собствен визуален компонент:

Разширете съществуващ клас View или неговите подкласове.
Заменете някои от методите на супер клас. Например методи, които започват с ‘on’: onDraw (), onMeasure (), onKeyDown (). Това е подобно на обработката на събития за активност, когато замените методите на жизнения цикъл.
Използвайте новия си клас. След като създадете клас, можете да го използвате вместо компонента, на който се основава.

Забележка: разширените класове могат да бъдат декларирани като вътрешни класове в рамките на явленията и използвани от тях. Това е удобно, защото ви позволява да контролирате достъпа до компонента, но не е задължително (може да искате да създадете нов публичен клас за широко използване в приложението).

Пълна персонализация на компонентите

Пълната персонализация може да се използва за създаване на графични компоненти, които изглеждат точно както искате. Може би графичен VU метър, който прилича на аналог или песенна линия, в която топката се движи над думата, която трябва да пеете в караоке. Тоест във всякакви ситуации, при които съществуващите компоненти не могат да правят това, което искате.

За щастие можете лесно да създавате компоненти, чийто външен вид и поведение са ограничени само от вашето въображение, размера на екрана и наличната мощност на устройството (не забравяйте, че приложението може да работи на устройства с по-малка мощност от вашето).

За да създадете такъв компонент:

Не е изненадващо, че най-общият клас, който можете да разширите, е View. Обикновено те започват с него, за да създадат своя нов суперкомпонент.
Можете да създадете конструктор, който може да приема атрибути и параметри от XML, и можете да използвате свои собствени атрибути.
Вероятно ще ви трябват ваши собствени слушатели на събития, достъп до свойства и модификатори на свойства и може би просто по-сложно поведение на компонентите.
Почти със сигурност ще трябва да замените метода onMeasure () и вероятно onDraw (), за да създадете облика на компонента. Въпреки факта, че и двата метода имат стандартна реализация, onDraw () не прави нищо и onMeasure () винаги задава размера на 100x100 - това най-вероятно не е това, от което се нуждаете.
Други методи на. може да бъде заменено, ако е необходимо.

Разширяване на методите onDraw () и onMeasure ()

Методът onDraw () ви предоставя платно, върху което можете да поставите каквото искате: 2D графика, други стандартни или персонализирани компоненти, текст и т.н.

Забележка: уви, тук не можете да прилагате 3D графика. Ако имате нужда от 3D, разширете класа SurfaceView вместо View и нарисувайте на отделна нишка. Вижте GLSurfaceViewActivity за пример.

Методът onMeasure () е малко по-сложен. Този метод е критичната точка между вашия компонент и контейнера, в който се намира. onMeasure () трябва да бъде заменен, за да се отчита ефективно и точно размерът на компонента. Това е малко по-трудно да се направи поради ограниченията, наложени от родителския компонент (който се предава на метода onMeasure ()) и поради изискванията за извикване на метода setMeasuredDimension (), преминавайки във височина и ширина веднага както са изчислени. Ако не сте извикали този метод от заменения метод onMeasure (), той ще изведе изключение.

На високо ниво методът onMeasure () трябва да изглежда по следния начин:

Методът на претоварено onMeasure () се извиква с мярка за височина и ширина (целочислените параметри widthMeasureSpec и heightMeasureSpec), която трябва да се третира като ограничение на височината и ширината. Вижте документацията за View.onMeasure (int, int) за пълно ръководство.
Вашият метод onMeasure () трябва да изчисли височината и ширината, които компонентът трябва да изобрази. Трябва да се опитате да не надхвърляте ограниченията, предадени на метода, но можете да ги надвишите (в този случай родителският контейнер може да реши какво да се направи: да отрежете компонента си, да добавите свитък, да хвърлите изключение или да се обадите onMeasure ) отново, вероятно с различни параметри на ограничения).
След като изчислите ширината и височината, трябва да извикате метода setMeasureDimension (int width, int height). Ако забравите да направите това, ще се появи изключение.

По-долу е даден списък на стандартните методи, които системата извиква за компоненти:

Пример за персонализиран компонент

Демонстрацията CustomView от API Demos съдържа нов компонент LabelView.

LabelView обхваща няколко различни аспекта на разработването на естествени компоненти:

Наследяване от класа View за създаване на изцяло нов компонент.
Параметризиран конструктор, който приема XML параметри. Някои от тях са преминали през суперклас, но по-важното е, че някои от техните собствени атрибути са описани и използвани за LabelView.
Внедряване на стандартни публични методи setText (), setTextSize (), setTextColor () и т.н.
Претоварен метод onMeasure за задаване на размера на компонента. (Обърнете внимание, че в LabelView методът private mereWidth () върши реалната работа).
Претоварен метод onDraw (), който изчертава надпис върху предоставената област.

Можете да видите пример за използване на LabelView във файла custom_view_1.xml. По-специално, можете да видите използването на двете пространства на имена android: и app:. Приложението. са нестандартни и са декларирани във вграден клас в клас R.

Комбиниране на компоненти

Ако не искате да създадете напълно нов компонент, но искате да сглобите компонент от няколко съществуващи, създаването на комбиниран компонент (Compound компонент) е това, от което се нуждаете. Накратко, това е групирането на няколко отделни компонента в логическо групиране, което може да се разглежда като едно нещо. Например падащ списък може да се разглежда като колекция от отделно текстово поле за въвеждане, бутон и изскачащ списък. Ако кликнете върху бутона и изберете нещо от списъка, този елемент попада в текстовото поле, но потребителят може също да напише нещо директно в това поле.

Android вече има два готови падащи компонента: Spinner и AutoCompleteTextView, просто концепцията за падащо меню е по-лесна за цитиране като пример.

За да създадете обединен компонент, трябва:

Обикновено началната точка е Layout, така че трябва да наследите класа на оформлението. Може би в случай на падащо меню можем да използваме хоризонтален LinearLayout. Не забравяйте, че други видове маркиране могат да бъдат вложени вътре, обединеният компонент може да бъде произволно сложен и структуриран. Имайте предвид, че както при явленията, можете да използвате XML или програмен подход.
В конструктора на новия клас първо приемете всички параметри, изисквани от суперкласа и първо извикайте конструктора на суперкласа с тези параметри. След това можете да персонализирате останалите компоненти; тук трябва да създадете поле за въвеждане и изскачащ списък. Имайте предвид, че можете също да включите свои собствени атрибути и параметри в XML, които могат да се използват във вашия конструктор.
Можете също да създадете слушатели на събития, например слушател за събитие за щракване върху списък, за да актуализирате съдържанието на текстово поле.
Можете също така да създадете свои собствени свойства с методи за достъп за тях, например да зададете текста в текстово поле и да го получите.
В случай на разширяване на класа Layout, не е необходимо да претоварвате методите onDraw () и onMeasure (), тъй като маркирането има собствена реализация. Ако обаче желаете, все още можете да направите това.
Можете да претоварите методите., като onKeyDown (), възможно е да изберете подходящи стойности в изскачащ списък при натискане на бутон.

По този начин използването на клас за маркиране като основа за вашите собствени компоненти има няколко предимства, включително:

Можете да създавате маркиране, като използвате XML файлове, сякаш просто създавате ново явление, можете също да създавате маркиране програмно.
Методите onDraw () и onMeasure () (плюс най-популярните на. Методи) вече са внедрени и не е необходимо да ги създавате.
В края на деня можете просто много бързо да съберете сложни комбинирани компоненти и да ги използвате повторно, сякаш са отделен компонент.

Примери за комбинирани компоненти

В демонстрационните проекти ще намерите два списъка с примери, Пример 4 и Пример 6, които демонстрират SpeachView и разширяват LinearLayout за показване на кавички. Класовете са във файловете List4.java и List6.java .

Промяна на съществуващ компонент View

Има още по-проста опция за създаване на собствени компоненти, които могат да бъдат полезни при определени обстоятелства. Ако вече съществува много подобен компонент, можете просто да го разширите и да замените поведението, което искате. Можете да правите всичко, което сте правили при създаването на компонент от нулата, но като започнете с по-подобен клас, можете лесно да получите готови функции.

Например демонстрационните проекти имат приложение NotePad. Това приложение показва много аспекти на използването на платформата Android, включително използването на компонента EditText за създаване на облицована тетрадка. Това не е най-добрият пример, но демонстрира принципите.

Ако все още го нямате, изтеглете образеца на NotePad и го импортирайте в Eclipse. По-специално, погледнете описанието на MyEditText във файла NoteEditor.java.

Ето някои неща, за които трябва да внимавате:

Определение

Класът започва със следния ред:
публичен статичен клас MyEditText разширява EditText

Създаден е като вложен клас във феномена NoteEditor, но е публичен, което означава, че е достъпен като NoteEditor.MyEditText от други класове.
Този клас е статичен, което означава, че той не създава така наречените „синтетични методи“, които ви позволяват достъп до данни от родителския клас, което от своя страна означава, че той се държи като отделен клас и няма силна връзка с класа NoteEditor .
Той наследява от класа EditText, който в този случай ще персонализираме. След завършване на конфигурацията, новият клас може да замени обичайния EditText .

Инициализация на класа

Конструкторът на суперклас винаги се извиква първи. Също така, не конструктор по подразбиране, а един от параметризираните конструктори. EditText се създава с тези параметри при зареждане от XML, така че нашият конструктор трябва да вземе тези параметри и да ги предаде на конструктора на супер клас.

Претоварени методи

В този пример само един метод е претоварен: onDraw () - но други могат да бъдат претоварени, ако е необходимо.

В примера на NotePad претоварването onDraw () ни позволява да нарисуваме сини линии върху платното EditText (платното се предава на метода onDraw ()). Методът super.onDraw () се извиква преди този метод да завърши. В този случай го наричаме след създаване на редовете, които искаме да включим в компонента.

Използване на вашия собствен компонент