Eclipse IDE– ში შეგიძლიათ მართოთ, შეცვალოთ, შეადგინოთ, გაუშვათ და გამართოთ პროგრამები. Eclipse ADT მოდული უზრუნველყოფს დამატებით ინსტრუმენტებს მომხმარებლებისთვის, რათა გამოიყენონ Android პროგრამები. თქვენ ასევე შეგიძლიათ გამოიყენოთ ADT მოდული Android პლატფორმის სხვადასხვა ვერსიების სამართავად. ეს აუცილებელია იმ პროგრამების შემუშავებისთვის, რომლებიც განკუთვნილია სხვადასხვა მოწყობილობებირომელზედაც დამონტაჟებულია სხვადასხვა ვერსია ოპერაციული სისტემა Android. Eclipse გარემოს პირველად დაწყების შემდეგ გამოჩნდება Welcome tab:

ეს ჩანართი შეიცავს უამრავ ხატის ბმულს, რომელზედაც დააწკაპუნებთ შესაბამის სექციებში.
დააწკაპუნეთ Workbench ღილაკზე საჩვენებლად პერსპექტივაჯავის განვითარება, რომელშიც იწყება Android პროგრამების შემუშავება. Eclipse მხარს უჭერს პროგრამების შემუშავებას რამდენიმე პროგრამირების ენაზე. თითოეული დაინსტალირებული Eclipse ინსტრუმენტების ყუთი წარმოდგენილია ცალკე
განვითარების პერსპექტივა.

ახალი პროექტის შექმნა
Eclipse– ში Android პროგრამირების დასაწყებად, შეასრულეთ ბრძანებები ფაილი-> NewProject ... ახალი პროექტის დიალოგის საჩვენებლად

ეს ფანჯარა ასევე შეიძლება ნახოთ ინსტრუმენტთა პანელზე ახალი ჩამოსაშლელი სიის გამოყენებით.

გააფართოვეთ Android კვანძი, შეარჩიეთ Android Application Project ვარიანტი და დააჭირეთ ღილაკს შემდეგი>. ეკრანზე გამოჩნდება ახალი Android პროექტის დიალოგი.

პროექტიარის დაკავშირებული ფაილების ჯგუფი, როგორიცაა კოდის ფაილები და სურათები, რომლებიც ქმნიან პროგრამას. ახალი პროექტის დიალოგში, თქვენ შეგიძლიათ შექმნათ პროექტი ნულიდან, ან გამოიყენოთ არსებული კოდის წყარო (მაგალითად, კოდი წიგნიდან ან Android SDK– ით მოწოდებული მაგალითები).

სხვათა შორის, ახალი Android პროგრამის ფანჯარა ძალიან შეიცვალა, დაწყებული სახელით და დამთავრებული შინაარსით. ასე რომ, ჩვენ ამას გავარკვევთ სპექტაკლის მსვლელობისას.
ასე რომ წავიდეთ! შეავსეთ ველები, როგორც ნაჩვენებია ეკრანის სურათზე

განაცხადის სახელი- ეს არის სახელი, რომელიც ნაჩვენები იქნება PlayStore– ში, ასევე აპლიკაციის მენეჯერში იმ მოწყობილობაზე, რომელზეც დაინსტალირდება პროგრამა.

პროექტის სახელი- გამოყენებული პროექტის სახელი მხოლოდდაბნელება. უნდა იყოს უნიკალური წარმოების გარემოში. როგორც წესი, ეს იგივეა, რაც განაცხადის სახელი, მაგრამ მე განსხვავებული გავხდი იმის გასაგებად, თუ სად გამოჩნდება სახელი.

პაკეტის სახელი- ეს სახელი უნდა იყოს თქვენი განაცხადის უნიკალური იდენტიფიკატორი. ანუ, დარწმუნებული უნდა იყოთ, რომ არავინ აღარ ასახელებს მათ განაცხადს ასე. და ეს სახელი უნდა დარჩეს უცვლელი ცხოვრების ციკლიპროგრამები (პროგრამის ვერსიები შეიძლება შეიცვალოს, მაგრამ სახელი იგივე უნდა დარჩეს).

მინიმალური მოთხოვნა SKD- მინიმალური Android ვერსია, რომელიც საჭიროა თქვენი პროგრამის ფუნქციონირებისათვის. ეს არსებითად ნიშნავს SDK– ის მინიმალურ ვერსიას, რომელიც საჭიროა პროგრამის სწორად ფუნქციონირებისთვის. გარდა ამისა, Android უბრალოდ არ მოგცემთ საშუალებას დააინსტალიროთ პროგრამა, თუ მოწყობილობას აქვს Android ვერსია, რომლის API ნომერი დაბალია ამ პარამეტრში მითითებულზე.

სამიზნე SDK- Android– ის სამიზნე ან მაქსიმალური ვერსია, რომელზეც პროგრამა ნამდვილად იმუშავებს და გამოცდილია. მიზანშეწონილია დააყენოთ ეს პარამეტრი რაც შეიძლება მაღალი.

შეადგინეთ SDK- თქვენ მიერ დაინსტალირებული SDK- ის ვერსია, რომელთანაც შედგენილი იქნება პროგრამა.

თემა- განაცხადის თემა.
ძირითადად, დეტალური აღწერაყველა ეს წერტილი არის ბურჟუაზიულ ენაზე და ხელმისაწვდომია, როდესაც თაგუნას ატარებ ლურჯ ხატზე ასოებით მე.

ასე რომ დააწკაპუნეთ შემდეგი და ნახეთ შემდეგი ფანჯარა

ჩვენ ვაშორებთ daw- ს შექმენით პერსონალური გამშვები ხატიჩვენ ვაჭერთ შემდეგი

აირჩიეთ ცარიელი აქტივობა და დააწკაპუნეთ შემდეგი და იხილეთ შემდეგი ფანჯარა

ჩვენ ვავსებთ როგორც ეკრანზე და ვაწკაპუნებთ დასრულებას და ვხედავთ Java პროექტის განვითარების პერსპექტივას

ყვითელში, მე გამოვყავი ის, რასაც განსაკუთრებული ყურადღება უნდა მიექცეს, რათა გაირკვეს, სად რომელი სახელებია ჩარჩენილი. შემდეგი, გააფართოვეთ კვანძი, შემდეგ განლაგების კვანძი და ორჯერ დააწკაპუნეთ main.xml– ზე და აი! ნახეთ როგორ გამოიყურება ჩვენი პროგრამა! დაწკაპვით main.xml, ჩვენ გამოვიყვანეთ ADT Visual Layout Editor. ის შეიძლება გამოყენებულ იქნას შესაქმნელად გრაფიკული ინტერფეისიმომხმარებლის მიერ პროგრამის ფანჯარაში გადაათრიეთ GUI კომპონენტები, როგორიცაა ღილაკები, TextViews, ImageViews და ა.შ.

ჩვენ ოდნავ შევცვლით ჩვენს გარემოს ისე, რომ ყველაფერი უკეთესად ჩანს

პროექტის კვანძში, პროექტის შინაარსი ორგანიზებულია სხვადასხვა ფაილში და საქაღალდეში, მათ შორის:
src- საქაღალდე, რომელიც შეიცავს Java პროექტის წყაროს ფაილებს;
გენ- საქაღალდე შეიცავს Java ფაილებიგენერირებული IDE;
Android 2.3.3- პროგრამის შექმნისას შერჩეული Android ჩარჩო ვერსიის შემცველი საქაღალდე;
რეს- საქაღალდე, რომელიც შეიცავს პროგრამასთან დაკავშირებულ რესურს ფაილებს, როგორიცაა GUI განლაგება და აპლიკაციაში გამოყენებული სურათები.
სხვა მამებს მოგვიანებით განვიხილავთ.
როდესაც თქვენ შექმნით Android პროგრამას Eclipse– ით, მომხმარებლის ინტერფეისის განლაგება ინახება XML ფაილში, რომელსაც სტანდარტულად ეწოდება main.xml. XML ფაილში GUI ელემენტების განსაზღვრით, თქვენ შეგიძლიათ მარტივად გათიშოთ პროგრამის ლოგიკა მისი პრეზენტაციიდან. განლაგების ფაილები არის პროგრამის რესურსები და ინახება პროექტის res საქაღალდეში. GUI განლაგება განლაგებულია განლაგების საქაღალდის ქვესაქაღალდეში.
ფაილის XML შინაარსის სანახავად შეარჩიეთ ჩანართი განლაგების ფაილის სახელით (in ამ საქმეს, მთავარი. xml). ვიზუალური განლაგების რედაქტორის ხედზე დასაბრუნებლად შეარჩიეთ გრაფიკული განლაგების ჩანართი.
პრინციპში, ეს პროგრამა უკვე შეიძლება ამოქმედდეს შესასრულებლად. მე გავუშვი Genymotion– ის გამოყენებით, რადგან ის ბევრად უფრო სწრაფია ვიდრე Android ემულატორი SDK– დან და თუნდაც Intel– დან.

სასარგებლო ვიდეო ამ თემაზე

ასე რომ, ჩვენ ვაგრძელებთ ექსპერიმენტებს ჩვენი პირველი პროექტის შესახებ.

წაშლა და ხელახლა შექმნა main.xml ფაილი
ამ თავისთვის განაცხადის შექმნის პროცესში, ახალი განლაგების ფაილი, RelativeLayout, გამოყენებული იქნება ნაგულისხმევი main.xml ფაილის ნაცვლად (ეს ფაილი განსაზღვრავს კომპონენტების ფარდობით პოზიციას). ნაგულისხმევი main.xml ფაილის შესაცვლელად, მიყევით ამ ნაბიჯებს:
1) დარწმუნდით, რომ main.xml ფაილი დახურულია, შემდეგ დააჭირეთ მასზე მარჯვენა ღილაკს (პროექტის / res / layout საქაღალდეში) და აირჩიეთ Delete ფაილის წასაშლელად.
2) Android კვანძში აირჩიეთ Android XML Layout File ვარიანტი და დააწკაპუნეთ შემდეგი

4) დარწმუნდით, რომ ფაილი შექმნილია / res / layout დირექტორიაში

დააწკაპუნეთ დასრულება და შედით უკვე ნაცნობ ფანჯარაში

ეკრანის ზომის და რეზოლუციის დაყენება ვიზუალური განლაგების რედაქტორში
ვინაიდან Android ოპერაციული სისტემა მუშაობს სხვადასხვა მოწყობილობებზე, Visual Layout Editor– ს გააჩნია სხვადასხვა მოწყობილობის კონფიგურაცია, რომელიც წარმოადგენს ეკრანის სხვადასხვა ზომას და გარჩევადობას. ეს პარამეტრები შერჩეულია მოწყობილობის კონფიგურაციების ჩამოსაშლელი სიიდან.

თუ ნაგულისხმევი კონფიგურაციები არ ემთხვევა იმ მოწყობილობას, რომლისთვისაც ვითარდება პროგრამა, თქვენ შეგიძლიათ შექმნათ თქვენი საკუთარი მოწყობილობის კონფიგურაცია "ნულიდან" ან არსებული კონფიგურაციის კოპირებითა და შეცვლით.
ამ წიგნის მაგალითების შესაქმნელად ჩვენ გამოვიყენეთ ძირითადი Samsung Nexus S სატესტო მოწყობილობა, რომელიც აღჭურვილია 4 დიუმიანი 480x800 პიქსელიანი (WVGA) ეკრანით. მიზანშეწონილია შემუშავდეს მასშტაბური Android GUI ბიბლიოთეკა, რომელიც სწორად ასახავს სურათებს სხვადასხვა მოწყობილობების ეკრანებზე. მისი მასშტაბურობის მახასიათებლის გამო, ვიზუალური განლაგების რედაქტორის დიზაინის არეალს არ სჭირდება ფიზიკური მოწყობილობის ეკრანებთან შესაბამისობა. საკმარისია აირჩიოთ მსგავსი მოწყობილობის კონფიგურაცია.

სურათებისა და ეკრანის ზომები და გარჩევადობა

იმის გამო, რომ Android მოწყობილობის ეკრანებს აქვთ სხვადასხვა ზომა, გარჩევადობა და ეკრანის პიქსელის სიმკვრივე (გამოხატულია წერტილებით ინჩზე ან DPI), გამოსახულებები (და სხვა რესურსები) მხარს უჭერს, რომლებიც არჩეულია ოპერაციული სისტემის მიერ მოწყობილობის ეკრანის პიქსელის სიმკვრივის საფუძველზე. ამიტომ, საქაღალდეში რესპროექტი შეიცავს ოთხ ქვე საქაღალდეს:
drawable-xhdpi(ულტრა მაღალი სიმკვრივე)
drawable-hdpi(მაღალი სიმკვრივის)
მიაპყროს-mdpi(საშუალო სიმკვრივე)
ხატვა-ldpi(დაბალი სიმკვრივე)

Android მოწყობილობების პიქსელის სიმკვრივე

xhdpiულტრა მაღალი სიმკვრივე - დაახ. 320 dpi
hdpiმაღალი სიმკვრივე - დაახ. 240 dpi
mdpiსაშუალო სიმჭიდროვე - დაახლოებით 160 dpi
ldpiდაბალი სიმკვრივე - დაახ. 120 dpi
nodpiრესურსების გაფართოება ეკრანის სიმკვრივის მიუხედავად
ნაბიჯი 1. პროექტში სურათების დამატება
ამისთვის ამ განაცხადისთქვენ უნდა დაამატოთ Deitel bug (bug.png) და Android ლოგო (android.png) სურათები პროექტში. ეს სურათები განთავსებულია სურათების საქაღალდეში წიგნის მაგალითებთან ერთად. თქვენს პროექტში სურათების დასამატებლად მიჰყევით ამ ნაბიჯებს:
1. Package Explorer ფანჯარაში გახსენით res პროექტის საქაღალდე.
2. იპოვეთ და გახსენით სურათების საქაღალდე, რომელიც არის წიგნის მაგალითებს შორის, შემდეგ გადაიტანეთ სურათები საქაღალდეში, რომელიც მდებარეობს res საქაღალდის drawable-hdpi ქვესაქაღალდეში.

ახლა სურათების გამოყენება შესაძლებელია აპლიკაციაში.

ნაბიჯი 2. RelativeLayout- ის Id ქონების შეცვლა
თვისებების ფანჯრის გამოყენებით, თქვენ შეგიძლიათ დააკონფიგურიროთ შერჩეული განლაგების ან კომპონენტის თვისებები XML– ის პირდაპირი რედაქტირების გარეშე. თუ თვისებების ფანჯარა არ ჩანს, ორჯერ დააწკაპუნეთ RelativeLayout ელემენტზე Outline ფანჯარაში, რომ გამოჩნდეს.

აირჩიეთ RelativeLayout კომპონენტი, შემდეგ გადაახვიეთ თვისებების ფანჯარაში, აირჩიეთ Id თვისება და მიანიჭეთ მნიშვნელობა მას:

@ + id / welcomeRelativeLayout

თითოეული ობიექტის სახელი განისაზღვრება მისი Id თვისების გამოყენებით. ეს თვისება შეიძლება გამოყენებულ იქნას კომპონენტზე წვდომისა და შეცვლის გარეშე
იცოდეთ კომპონენტის ზუსტი ადგილმდებარეობა XML– ში. როგორც მოგვიანებით ნახავთ, Id თვისება ასევე შეიძლება გამოყენებულ იქნას კომპონენტების ფარდობითი პოზიციონირებისათვის RelativeLayout- ში.

სიმბოლო + მშენებლობაში @ + idგანსაზღვრავს ახალი იდენტიფიკატორის (ცვლადის სახელის) შექმნას, რომელიც მითითებულია სიმბოლოს მარჯვნივ /

ნაბიჯი 3. RelativeLayout- ის Background თვისების მნიშვნელობად დაყენება
სტანდარტულად, თეთრი შეირჩევა განლაგების ფონის ფერიდ (ჩვენს შემთხვევაში), მაგრამ ის შეიძლება შეიცვალოს (მაგალითად, ყვითელში). ნებისმიერი ფერი არის წითელი, ლურჯი და მწვანე კომპონენტების ნარევის შედეგი, რომელსაც RGB კომპონენტები ეწოდება. თითოეულ ამ კომპონენტს შეუძლია მიიღოს მთელი მნიშვნელობა 0 -დან 255 -მდე დიაპაზონში. პირველი კომპონენტი განსაზღვრავს წითელი ფერის საერთო ფერს, მეორე - მწვანე, ხოლო მესამე - ლურჯის რაოდენობას. ინტეგრირებული განვითარების გარემოში (IDE) მუშაობისას ჰექსადეციმალური ფორმატი გამოიყენება ფერის განსაზღვრისათვის. ანუ, RGB კომპონენტები წარმოდგენილია როგორც ღირებულებები დიაპაზონში 00 - FF.
ფონის ფერის შესაცვლელად, იპოვეთ ფონის თვისება თვისებების ფანჯარაში და დააყენეთ #FFFF33

# RRGGBB ფორმატი წყვილებშია თექვსმეტობითი რიცხვებირომლებიც შესაბამისად წითელი, მწვანე და ლურჯია. Android ასევე მხარს უჭერს ალფა მნიშვნელობებს (გამჭვირვალობა), რომლებიც მერყეობს 0-255-დან. 0 მნიშვნელობა არის სრულად გამჭვირვალე, ხოლო 255 - სრულად გაუმჭვირვალე. თუ თქვენ აპირებთ ალფა მნიშვნელობების გამოყენებას, მიუთითეთ ფერი #AARRGGBB ფორმატში, სადაც პირველი ორი თექვსმეტობითი ციფრი შეესაბამება ალფას მნიშვნელობას.
თუ თითოეული ფერის კომპონენტის ორივე ციფრი ერთნაირია, შეგიძლიათ გამოიყენოთ # RGB ან #ARGB ფორმატი. მაგალითად, # FFF განიხილება, როგორც #FFFFFF.

ნაბიჯი 4. TextView კომპონენტის დამატება
ამ ნაბიჯში ჩვენ დავამატებთ TextView კომპონენტს UI- ში. ფორმა ვიჯეტების სიაში Visual Layout Editor– ის მარცხენა მხარეს იპოვეთ TextView კომპონენტი და გადაიტანეთ იგი დიზაინის არეზე

მომხმარებლის კომპონენტში ახალი კომპონენტის დამატების შემდეგ ის ავტომატურად ირჩევა და მისი თვისებები გამოჩნდება თვისებების ფანჯარაში.

ნაბიჯი 5. TextView კომპონენტის Text თვისების დაყენება სიმებიანი რესურსების გამოყენებით

Android დოკუმენტაციის თანახმად, პროგრამის რესურსებისთვის (developer.android.com/guide/topics/resources/index.html), კარგი პრაქტიკაა სტრიქონების, სტრიქონების მასივების, სურათების, ფერების, შრიფტის ზომის, ზომების და სხვა აპლიკაციის შესანახად. რესურსები ისე, რომ მათი გამოყენება შესაძლებელია განაცხადის კოდისგან დამოუკიდებლად. მაგალითად, ფერის მნიშვნელობების ექსტერიერიზაციის შემდეგ, ერთი და იმავე ფერის ყველა კომპონენტის ხელახლა შეღებვა შესაძლებელია ცენტრალური რესურსის ფაილის ფერის მნიშვნელობის შეცვლით.
თუ თქვენ გჭირდებათ თქვენი პროგრამების ლოკალიზება სხვადასხვა ენაზე ვერსიების შექმნით, შეინახეთ სტრიქონები განაცხადის კოდისგან. შედეგად, თქვენ შეძლებთ მომავალში ადვილად შეცვალოთ ეს ხაზები. პროექტის res საქაღალდე შეიცავს ღირებულებების ქვესაქაღალდეს, რომელიც შეიცავს strings.xml ფაილს. ეს ფაილი გამოიყენება სტრიქონების შესანახად. სხვა ენებისთვის ლოკალიზებული სტრიქონების შესაქმნელად, შექმენით ცალკეული მნიშვნელობების საქაღალდე თითოეული გამოყენებული ენისთვის.
მაგალითად, values-fr საქაღალდე შეიძლება შეიცავდეს strings.xml ფაილს ფრანგულ ენაზე, ხოლო value-es საქაღალდე შეიძლება შეიცავდეს strings.xml ფაილს ესპანურად. თქვენ ასევე შეგიძლიათ ჩამოაყალიბოთ ამ საქაღალდეების სახელები რეგიონის შესახებ ინფორმაციის გათვალისწინებით. მაგალითად, values-en-US საქაღალდე შეიძლება შეიცავდეს strings.xml ფაილს ინგლისური ამერიკული დიალექტისთვის, ხოლო values-en-GB საქაღალდე შეიძლება შეიცავდეს strings.xml ფაილს ინგლისური ენის დიდი ბრიტანეთის დიალექტისთვის.
ლოკალიზაციის შესახებ დამატებითი ინფორმაციისათვის მიმართეთ რესურსებს:

Developer.android.com/guide/topics/resources/;
უზრუნველყოფა-რესურსები. html.AlternativeResources;
developer.android.com/guide/topics/resources/localization.html.

TextView კომპონენტის Text თვისების მნიშვნელობის დასადგენად, შექმენით ახალი სიმებიანი რესურსი strings.xml ფაილში.

1. აირჩიეთ TextView კომპონენტი.
2. თვისებების ფანჯარაში იპოვეთ Text თვისება, დააწკაპუნეთ ნაგულისხმევზე, ​​შემდეგ დააჭირეთ ელიფსის ღილაკს. ეს ღილაკი არის მარჯვნივ
ნაწილი ქონების ღირებულების ველში და აჩვენებს Resource Chooser დიალოგურ ფანჯარას.

3. Resource Chooser დიალოგურ ფანჯარაში დააწკაპუნეთ New String… ღილაკზე, რომ ნახოთ ახალი Android String შექმნა დიალოგური ფანჯარა.
Android სტრიქონი)

4. შეავსეთ String და New R.string ველები, შემდეგ დააწკაპუნეთ OK დამალვა Create New Android String დიალოგური ფანჯარა და დაუბრუნდით Resource Chooser ფანჯარას.

5. ახალი სიმებიანი რესურსის მისასალმებელი ავტომატურად არის არჩეული. დააწკაპუნეთ OK ღილაკზე ამ რესურსის შესარჩევად.

ზემოაღნიშნული ნაბიჯების დასრულების შემდეგ, ტექსტის თვისება გამოჩნდება თვისებების ფანჯარაში. @String ჩანაწერი მიუთითებს, რომ არსებული სიმებიანი რესურსი შეიძლება შეირჩეს strings.xml ფაილში, ხოლო სახელი welcome მიანიშნებს, რომ სიმებიანი რესურსი ამჟამად არჩეულია.

სიმებიანი მნიშვნელობების განსაზღვრის მთავარი უპირატესობა ის არის, რომ ეს აადვილებს პროგრამის ლოკალიზაციას დამატებითი შექმნის გზით
XML რესურსის ფაილები სხვა ენებისთვის. თითოეული ფაილი იყენებს იმავე სახელს New R.string ველში და ინარჩუნებს ინტერნაციონალიზებულ სტრიქონს სიმების ველში. Android- ს შეუძლია შეარჩიოს შესაბამისი რესურსის ფაილი მოწყობილობის მომხმარებლის სასურველი ენის საფუძველზე. ლოკალიზაციის შესახებ მეტი ინფორმაცია შეგიძლიათ იხილოთ developer.android.com/guide/topics/resources/localization.html.

ნაბიჯი 6. TextView კომპონენტის ტექსტის ზომის და Padding ზედა თვისებების დაყენება - პიქსელები სიმკვრივისა და მასშტაბისგან დამოუკიდებლად

GUI კომპონენტების ზომები და ტექსტი ჩართულია ანდროიდის ეკრანიშეიძლება განისაზღვროს სხვადასხვა ერთეულის გამოყენებით.
ეკრანის სხვადასხვა ზომის აღმწერი დოკუმენტაცია შეგიძლიათ იხილოთ developer.android.com/guide/practices/screens_support.html და გირჩევთ გამოიყენოთ სიმკვრივისგან დამოუკიდებელი პიქსელები GUI კომპონენტების და ეკრანზე სხვა ელემენტების გასაზომად და შრიფტის ზომის გამოყენება პიქსელებისგან დამოუკიდებლად სკალირება.

სიმკვრივისგან დამოუკიდებელი პიქსელის ზომები (დპ ან დიპ) საშუალებას აძლევს Android პლატფორმას ავტომატურად გააფართოვოს GUI ფიზიკური მოწყობილობის ეკრანის პიქსელის სიმკვრივის საფუძველზე.
სიმკვრივისგან დამოუკიდებელი პიქსელის ზომა უდრის ფიზიკურ პიქსელს 160 dpi (წერტილები ინჩზე) ეკრანზე. ეკრანზე რეზოლუციით
სიმკვრივისგან დამოუკიდებლად 240 dpi პიქსელის ზომა გაფართოვდება 240/160 ფაქტორით (ანუ 1.5). ამრიგად, კომპონენტი, რომელიც არის სიმკვრივისგან დამოუკიდებელი 100 პიქსელი, გაიზრდება 150 ეკრანზე ასეთ ეკრანზე. 120 dpi ეკრანზე, თითოეული სიმკვრივის დამოუკიდებელი პიქსელი გაფართოვებულია 120/160 ფაქტორით (ანუ 0.75). ეს ნიშნავს, რომ სიმკვრივისგან დამოუკიდებლად 100 პიქსელი ასეთ ფიზიკურ ეკრანზე 75 ფიზიკურ პიქსლად გადაიქცევა. მასშტაბიდან დამოუკიდებელი პიქსელები მასშტაბირდება ისევე, როგორც სიმკვრივისგან დამოუკიდებელი პიქსელები, მაგრამ მათი მასშტაბი ასევე დამოკიდებულია მომხმარებლის სასურველი შრიფტის ზომაზე.
ახლა მოდით გავზარდოთ შრიფტის ზომა TextView კომპონენტისთვის და დავამატოთ მცირე ზომის ბალიში TextView კომპონენტის ზემოთ.
1. შრიფტის ზომის შესაცვლელად შეარჩიეთ TextView კომპონენტი და შემდეგ დააყენეთ Text size თვისება 40 sp.
2. განლაგების ზედა ზღვარსა და TextView- ს შორის ზღვრის გასაზრდელად აირჩიეთ Layout margin top თვისება თვისებების ფანჯრის Misc განყოფილებაში.
და მიანიჭეთ მას მნიშვნელობა 10 დპ.

ნაბიჯი 7. TextView კომპონენტის დამატებითი თვისებების დაყენება
TextView კომპონენტის დამატებითი თვისებების კონფიგურაცია შემდეგნაირად:
1. დააყენეთ Id თვისება @ + id / welcomeTextView.
2. დააყენეთ Text color თვისება # 00F (ლურჯი).
3. დააყენეთ Text style თვისება თამამად. ამისათვის დააწკაპუნეთ ამ ქონების Valu ველში, შემდეგ დააჭირეთ ელიფსისის ღილაკს, რომ ნახოთ დიალოგური ფანჯარა, სადაც შეგიძლიათ აირჩიოთ შრიფტის სტილი. შეამოწმეთ თამამი ველი, შემდეგ დააჭირეთ ღილაკს OK ტექსტის სტილის ასარჩევად.
4. დააყენეთ Gravity თვისება ცენტრში TextView ტექსტის ცენტრში, როდესაც ის გავრცელებულია მრავალ ხაზზე. აღსრულებისთვის
ამ ოპერაციისთვის დააწკაპუნეთ ამ ქონების ღირებულების ველზე, შემდეგ დააჭირეთ ელიფსისის ღილაკს, რომ ნახოთ თვისებების პარამეტრების დიალოგური ფანჯარა.
გრავიტაცია



ნაბიჯი 8. ჩვენება Android ლოგოები და Deitel Bug ImageViews კომპონენტების გამოყენებით
1. გადაიტანეთ ImageView კომპონენტი, რომელიც მდებარეობს Visual Layout Editor პალიტრის Images & Media კატეგორიაში, Outline ფანჯარაში. WelcomeTextView კვანძის ქვემოთ ჩნდება ახალი ImageView კომპონენტი.

2. დააყენეთ ImageView კომპონენტის Id თვისება @ + id / droidImageView. Outline ფანჯარა აჩვენებს droidImageView ობიექტის სახელს.

3. დააყენეთ droidImageView– ის განლაგების ცენტრის ჰორიზონტალური თვისება true– ზე, რათა განლაგდეს ImageView კომპონენტი.

4. კონტენტის აღწერის ველი დააყენეთ @ string / droidPic

5. იგივე გააკეთეთ bug.png ნახაზზე. დააყენეთ კომპონენტის Id თვისება @ + id / bugImageView.

მოდით, გავუშვათ ჩვენი პირველი პროგრამა :)

დღეს ჩვენ გვაქვს ამოცანა: დავაკონფიგურიროთ Eclipse Android განვითარებისათვის.

შემდეგი ნივთები იქნება საჭირო:

1. დაბნელება (მე ვიყენებ კლასიკას)
2. Android დეველოპერის ინსტრუმენტები (ADT)
3. Android SDK

პირველი რაც თქვენ გჭირდებათ არის განვითარების გარემო (IDE). Android- ზე ეს არის Eclipse. შეგიძლიათ გადმოწეროთ ოფიციალური ვებგვერდიდან: http://www.eclipse.org/downloads/ (გადმოწერეთ კომპიუტერზე დაინსტალირებული ოპერაციული სისტემის სიწმინდის შესაბამისად). შესანიშნავია, რომ Eclipse ხელმისაწვდომია Windows, Linux და Mac– ისთვის. ის ასევე უფასოა. Eclipse არ არის დაინსტალირებული - საკმარისია გადმოწეროთ და გახსნათ დისკზე ცალკე საქაღალდეში (უმჯობესია შექმნათ საქაღალდე სადღაც რუსული ასოების გარეშე)

JDK საჭიროა Eclipse და Java მუშაობისთვის. შეგიძლიათ გადმოწეროთ Oracle ვებსაიტზე. JRE ვერსია საკმარისი იქნება.

გაიხსნება ფანჯარა, რომელშიც თქვენ უნდა მიუთითოთ url სერვერზე, სადაც პაკეტი მდებარეობს. Google- ს აქვს შემდეგი მისამართი: https://dl-ssl.google.com/android/eclipse/, შემდეგ თქვენ უნდა შეამოწმოთ დეველოპერის ინსტრუმენტების ყველა ელემენტი და დააწკაპუნოთ შემდეგი

ოსტატი დააინსტალირებს ADT. ამის შემდეგ, თქვენ უნდა გადატვირთოთ Eclipse.

შემდეგი, თქვენ უნდა წავიდეთ და ჩამოტვირთოთ Android SDK. ეს შეიძლება გაკეთდეს ოფიციალურ ვებგვერდზე. თქვენ უნდა გადმოწეროთ ბინ - ეს უფრო მოსახერხებელია. ამის შემდეგ თქვენ უნდა დააკავშიროთ SDK და Eclipse:

გადადით ფანჯარაში -> პრეფერენცია -> Android

მიუთითეთ ადგილმდებარეობა, სადაც SDK დაინსტალირდა SDK მდებარეობის ტექსტურ ყუთში. ნაგულისხმევად, ეს არის: C: \ Program Files (x86) \ Android \ android-sdk

ბოლო ნაბიჯი არის ამ SDK- ის განახლება. გადადით ფანჯარაში -> Android SDK მენეჯერი. გაიხსნება მსგავსი ფანჯარა (მე უკვე ყველაფერი დაყენებული მაქვს):

მეგობრულად, აქ შეგიძლიათ აირჩიოთ ყველა პაკეტი და დააწკაპუნოთ ღილაკზე „პაკეტების დაყენება“. და შეგიძლია წახვიდე და ყავა დალიო. პროცესი ერთ საათზე მეტხანს გაგრძელდება. მთხოვეს პაროლი პაროლისთვის არა Google– დან - ჩვენ უარს ვამბობთ და გამოვტოვებთ - ის მაინც იმუშავებს.

პრობლემა

გსურთ გამოიყენოთ Eclipse გარემო თქვენი აპლიკაციის Android პლატფორმის შესაქმნელად.

გადაწყვეტა

დააინსტალირეთ Eclipse გარემო და AndMore დანამატი. შემდეგ შექმენით თქვენი პროექტი და დაიწყეთ თქვენი პროგრამის წერა. ააშენეთ იგი და გამოსცადეთ ემულატორი Eclipse– ში.

დისკუსია

სანამ დაიწყებთ პროგრამის შექმნას Eclipse– ით, თქვენ უნდა დააინსტალიროთ სამი ელემენტი:

• დაბნელება IDE
• Android SDK
• და მეტი მოდული

ამ ნივთების დაყენების დეტალებისათვის იხილეთ.

ამის შემდეგ, შექმენით ახალი Android პროექტი File → New მენიუს გამოყენებით და ნახავთ ეკრანს, როგორიც არის ნახ. 1

აირჩიეთ SDK ვერსია სამიზნე მოწყობილობისთვის (სურათი 3). ვერსია 4.0 მოიცავს თითქმის ყველა მოწყობილობას, რომელიც დღეს გამოიყენება; გვიანდელი ვერსიები კიდევ უფრო მეტ ვარიანტს იძლევა. Შენ გადაწყვიტე!

ბრინჯი 1

ბრინჯი 2

ბრინჯი 3

ლეღვი 4 გვიჩვენებს პროექტის სტრუქტურა გაფართოებულ პროექტის სარკმელში მარჯვნივ. ის ასევე აჩვენებს, თუ რამდენად შეგიძლიათ გამოიყენოთ Eclipse ავტომატური დასრულება Android პლატფორმაზე - მე დავამატე ეტიკეტის სიმძიმის ატრიბუტი და დაბნელების გარემოგთავაზობთ ატრიბუტების შესაძლო მნიშვნელობების სრულ ჩამონათვალს. მე ავირჩიე ცენტრალური-ჰორიზონტალური, ასე რომ მალსახმობი უნდა იყოს ორიენტირებული პროგრამის დაწყებისას.

ბრინჯი 4

სიმძიმის დაყენება ცენტრალურ_ ვერტიკალურზე LinearLayout– ში და center_horizontal TextView– ში ტექსტს ცენტრალიზდება როგორც ვერტიკალურად, ასევე ჰორიზონტალურად. ჩამონათვალი 1 აჩვენებს შესაბამის main.xml განლაგების ფაილს (მდებარეობს res / layout დირექტორიაში).

ჩამონათვალი 1. ფაილი Გამარჯობა მსოფლიო. ჯავა

როგორც ყოველთვის, როდესაც შეინახავთ წყაროს ფაილს, Eclipse გარემო წარმოქმნის შედგენილ ვერსიას. Android პროექტში ის ასევე ქმნის შედგენილ ARC პაკეტს, რომელიც მზად არის გასაშვებად, ასე რომ თქვენ მხოლოდ მისი გაშვება გჭირდებათ. დააწკაპუნეთ პროექტზე მარჯვენა ღილაკით და აირჩიეთ Run As → Android Application (სურათი 5).

გამომდინარე იქიდან, რომ ზოგიერთს არ შეუძლია დაიწყოს ჩემი პროექტები და მათთან საუბრის შემდეგ მივხვდი, რომ პრობლემა არ არის კოდში, არამედ Eclipse + Android SDK- ის შეკრებაში, გადავწყვიტე დავწერო, თუ როგორ უნდა დამედო ეს სილამაზე, და მოიყვანე გონებაში.

Eclipse და Android SDK დაყენება

• ჩამოტვირთეთ Android SDK თქვენი პლატფორმისთვის (Windows, Mac OS X ან Linux).
• გადმოტვირთეთ გადმოტვირთული ფაილები თქვენს მყარ დისკზე მეხსიერების ნებისმიერ ადგილას (ჩემს Windows- ზე ეს არის D: \ eclipse \).
• თუ Eclipse უკვე დაინსტალირებულია, ჩამოტვირთეთ და დააინსტალირეთ Eclipse IDE for Java Developers პაკეტი. პროგრამირებისთვის Google გირჩევთ გამოიყენოთ Eclipse 3.5 (გალილეო).
• დაიწყეთ დაბნელება და აირჩიეთ დახმარება-> დააინსტალირეთ ახალი პროგრამული უზრუნველყოფა.
• Დააკლიკეთ დამატებახელმისაწვდომი პროგრამული უზრუნველყოფის ფანჯარაში.
• შეიყვანეთ Android განვითარების ინსტრუმენტები ყუთში სახელიდა https://dl-ssl.google.com/android/eclipse/ ყუთში მდებარეობა.
• Დააკლიკეთ კარგიდა შეამოწმე დეველოპერის ინსტრუმენტებიხელმისაწვდომი პროგრამული უზრუნველყოფის ჩამონათვალში. ეს დააინსტალირებს Android განვითარების ინსტრუმენტებს და DDMS, გამართვის ინსტრუმენტს Android- ისთვის. თუ რაიმე პრობლემა გაქვთ ADT– ს დაყენებასთან დაკავშირებით, გამოიყენეთ ADT 15.0– ის ძველი ვერსია. განაახლეთ 15.0 ვერსიაზე

Android პლატფორმის სამიზნე

სანამ დაიწყებთ Android პროგრამების წერას, თქვენ უნდა ჩამოტვირთოთ Android SDK. თითოეულ პლატფორმას აქვს Android SDK- ის საკუთარი ვერსია, რომელიც დაინსტალირებულია მომხმარებლების მოწყობილობებზე. არსებობს ორი პლატფორმა Android 1.5 და უფრო მაღალი ვერსიისთვის: Android ღია კოდის პროექტიდა Google

Android ღია კოდის პროექტი- ღია კოდის პლატფორმა, მაგრამ არ შეიცავს Google გაფართოებები, როგორიცაა Გუგლის რუკა.თუ არ გსურთ გამოიყენოთ Google API, ფუნქციონირება გუგლის რუკამიუწვდომელი იქნება თქვენი განაცხადისათვის. თუ ამის კონკრეტული მიზეზი არ გაქვთ, მე გირჩევთ, რომ Google– ის ერთ – ერთ პლატფორმაზე მიუთითოთ, რადგან ეს საშუალებას მოგცემთ გამოიყენოთ Google– ის საკუთარი გაფართოებები.

• გთხოვთ აირჩიოთ ფანჯარა-> Android SDK მენეჯერი.
• Დააკლიკეთ ხელმისაწვდომი პაკეტებიმარცხენა სვეტში და შეამოწმეთ საცავი, რომ ნახოთ ხელმისაწვდომი Android პლატფორმების სია.
• თქვენ შეგიძლიათ შეარჩიოთ პლატფორმები ჩამოსატვირთად სიიდან, ან დატოვოთ ყველა მონიშნული ყველა არსებული პლატფორმის ჩამოსატვირთად. როდესაც დასრულდება, დააწკაპუნეთ დააინსტალირეთ არჩეულიდა მიჰყევით ინსტალაციის ინსტრუქციას.
  
  

მას შემდეგ რაც ყველაფერი წარმატებით გადმოწერილია, თქვენ მზად ხართ დაიწყოთ განვითარება Android- ისთვის.

ახალი Android პროექტის შექმნა

Eclipse New Project Wizard დაგეხმარებათ შექმნას Android აპლიკაციაფაილების და კოდის გენერირებით, მზად არის გასაშვებად, ბლოკის მარჯვნივ. ის სწრაფი გზადარწმუნდით, რომ ის მუშაობს და არის კარგი ამოსავალი წერტილი პროგრამის შემუშავების დაწყებისას:

დაწკაპუნების შემდეგ დასრულება Eclipse შექმნის ახალ Android პროექტს, რომელიც მზად არის გასაშვებად. გახსოვდეთ, თქვენ თქვით Eclipse– ის გენერირება აქტივობის სახელწოდებით MyFirstAndroidProjectActivity ? ეს არის კოდი, რომელსაც Android იყენებს რეალურად პროგრამის გასაშვებად. გენერირებული კოდი ნაჩვენები იქნება როგორც მარტივი "Hello World" შეტყობინება.

პაკეტები

პაკეტის სახელი არის თქვენი აპლიკაციის იდენტიფიკატორი. როდის არის შედეგის გამოქვეყნების დრო Android Market, ეს ID გამოყენებული იქნება აპლიკაციის განახლებების თვალყურის დევნებისთვის, ამიტომ მნიშვნელოვანია დარწმუნდით, რომ ეს ID უნიკალურია... მიუხედავად იმისა, რომ ჩვენ ვიყენებთ სახელს com.my.first.project აქ, რეალური აპლიკაციისთვის უმჯობესია აირჩიოთ com.yourcompanyname.yourapplication.

SDK ვერსიები

Min SDK ვერსია (სახელი თავისთავად მეტყველებს) არის ყველაზე მეტად ადრეული ვერსია Android, რომელზეც პროგრამა იმუშავებს. Android– ის ყოველი ახალი გამოშვებით, SDK ამატებს და ცვლის სხვადასხვა მეთოდს. SDK ვერსიის არჩევისას, Android- მა (და Android Market- მა) იცის, რომ თქვენი აპლიკაცია იმუშავებს მხოლოდ მითითებულ და უფრო მაღალი ვერსიის მოწყობილობებზე.

თქვენი აპლიკაციის გაშვება

ახლა შევეცადოთ გაუშვათ ჩვენი პროგრამა Eclipse– ში. ვინაიდან ეს არის პირველი გაშვება, Eclipse გკითხავთ რომელ პროექტზე მუშაობთ:

• გთხოვთ აირჩიოთ გაიქეცი-> გაიქეციან დააჭირეთ Ctrl + F11.
• გთხოვთ აირჩიოთ Android აპლიკაციადა დააჭირეთ კარგი.

Eclipse შეეცდება პროგრამის გაშვებას Android მოწყობილობაზე. ამ დროისთვის, თქვენ არ გაქვთ მოწყობილობები Android, ასე რომ პროექტი ჩავარდება და მოგეთხოვებათ ახალი მოწყობილობის შექმნა Android ვირტუალური მოწყობილობა(AVD).

ვირტუალური მოწყობილობები (Android ვირტუალური მოწყობილობები)

Android ვირტუალური მოწყობილობა (AVD) ემსგავსება Android გარემოს, იქნება ეს მობილური ტელეფონი თუ პლანშეტური კომპიუტერი. თქვენ შეგიძლიათ შექმნათ იმდენი AVD, რამდენიც გსურთ, Android პლატფორმის სხვადასხვა ვერსიით. თითოეული AVD– სთვის შეგიძლიათ დააკონფიგურიროთ მოწყობილობის სხვადასხვა პარამეტრი, მიუთითოთ ფიზიკური კლავიატურის არსებობა, GP მხარდაჭერა, კამერის გარჩევადობა და ა.

პროგრამის გაშვებამდე, თქვენ უნდა შექმნათ თქვენი პირველი AVD SDK პლატფორმით (Google API, 1.6).

ამ სახელმძღვანელოში თქვენ შეისწავლით თუ როგორ დაიწყოთ განვითარება Android- ისთვის, კერძოდ: მობილური პროგრამები Android Eclipse + SDK პლატფორმაზე. დღეს, Android– ისთვის მობილური აპლიკაციების შემუშავებისა და შექმნის მრავალი მიდგომა არსებობს. დახვეწილი აპარატურა, პლანშეტური კომპიუტერები და სხვადასხვა პროგრამული პლატფორმები(Symbian OS, iOS, WebOS, Windows Phone 7 ...) გახსენით გაუთავებელი სივრცე დეველოპერებისთვის.

ასე რომ, აპლიკაციების ჩამონათვალი Android– ისთვის მობილური აპლიკაციების შემუშავების დასაწყებად უზარმაზარია. რომელი პლატფორმა უნდა აირჩიოთ? რა პროგრამირების ენა უნდა ვისწავლოთ? რომელი პროგრამის არჩევა აირჩიოს პროექტის დაგეგმვისთვის? ამ სახელმძღვანელოში თქვენ შეისწავლით თუ როგორ დაიწყოთ მობილური აპლიკაციების შემუშავება Android პლატფორმისთვის, ღია კოდის მობილური ოპერაციული სისტემა Google– დან.

რატომ Android პლატფორმა?

Android არის ღია პლატფორმა დაფუძნებული Linux ბირთვი... იგი დამონტაჟებულია ათასობით მოწყობილობაზე მწარმოებლების ფართო სპექტრისგან. Android გთავაზობთ პროგრამებს ყველა სახის აპარატურაზე, რომლის წარმოდგენაც შესაძლებელია თანამედროვე მობილური მოწყობილობები- ციფრული კომპასი, ვიდეოკამერები, GPS, სენსორები და სხვა.

Android– ის განვითარების უფასო ინსტრუმენტები იწყებს სწრაფად ან უფასო პროგრამების შექმნას. როდესაც მზად იქნებით აჩვენოთ თქვენი პროგრამა მსოფლიოს, შეგიძლიათ გამოაქვეყნოთ იგი Android Market– ის საშუალებით. Android Market– ზე გამოქვეყნება მოითხოვს ერთჯერადი რეგისტრაციის საფასურს (25 დოლარი წერის დროს) და აპისგან განსხვავებით შეინახეთ Apple(რაც ძალიან მკაცრია ცენზურის შესახებ) თქვენს განაცხადს ხელმისაწვდომს ხდის გადმოსატვირთად და შესყიდვისათვის სწრაფი განხილვის შემდეგ - მანამ, სანამ აპლიკაცია არ არღვევს წესებსა და კანონს.

აქ არის რამოდენიმე სხვა Android SDK განსხვავება, რომელიც გთავაზობთ სარგებელს, როგორც დეველოპერს:

• Android SDK ხელმისაწვდომია Windows, Mac და Linux, ასე რომ თქვენ არ უნდა გადაიხადოთ ახალი ტექნიკა პროგრამების დასაწერად.
• SDKჩაშენებულია ჯავაში. თუ თქვენ კარგად იცნობთ Java პროგრამირების ენას, თქვენ უკვე შუა გზაზე ხართ.
• Android Market– ის საშუალებით აპლიკაციის განაწილების გათვალისწინებით, ის დაუყოვნებლივ იქნება ხელმისაწვდომი ასობით ათასი მომხმარებლისთვის. თქვენ არ შემოიფარგლებით მხოლოდ ოფიციალური ბაზრით, რადგან არსებობს ალტერნატივები. მაგალითად, თქვენ შეგიძლიათ გამოაქვეყნოთ აპლიკაცია თქვენს ბლოგებზე. ამბობენ, რომ Amazon ამზადებს საკუთარ Android აპლიკაციების მაღაზიას.
• SDK– ის ტექნიკური დოკუმენტაციის გარდა, ახალი რესურსები იქმნება Android დეველოპერებისთვის. პლატფორმა სულ უფრო მეტ პოპულარობას იძენს მომხმარებლებსა და დეველოპერებს შორის.

შეწყვიტე საუბარი - დავიწყოთ Android პროგრამების განვითარება!

Eclipse და Android SDK დაყენება

Android პლატფორმის ორიენტაცია განვითარების პროცესში

სანამ დაიწყებთ Android პროგრამების წერას, თქვენ უნდა ჩამოტვირთოთ Android SDK. თითოეულ პლატფორმას აქვს Android SDK- ის საკუთარი ვერსია, რომელიც დაინსტალირებულია მომხმარებლების მოწყობილობებზე. არსებობს ორი პლატფორმა Android 1.5 და უფრო მაღალი ვერსიისთვის: Android Open Source Project და Google.

Android ღია კოდის პროექტი არის ღია კოდის პლატფორმა, მაგრამ არ შეიცავს Google გაფართოებებს, როგორიცაა Google Maps. თუ არ გსურთ გამოიყენოთ Google API, Google Maps ფუნქციონირება მიუწვდომელი იქნება თქვენი აპლიკაციისთვის. თუ ამის კონკრეტული მიზეზი არ გაქვთ, მე გირჩევთ, რომ Google– ის რომელიმე პლატფორმაზე მიუთითოთ, რადგან ეს საშუალებას მოგცემთ გამოიყენოთ Google– ის საკუთარი გაფართოებები.

• აირჩიეთ ფანჯარა-> Android SDK და AVD მენეჯერი.
• დააწკაპუნეთ ხელმისაწვდომი პაკეტები მარცხენა სვეტში და შეამოწმეთ საცავი, რომ ნახოთ ხელმისაწვდომი Android პლატფორმების სია.
• თქვენ შეგიძლიათ შეარჩიოთ პლატფორმები ჩამოსატვირთად სიიდან, ან დატოვოთ ყველა მონიშნული ყველა არსებული პლატფორმის ჩამოსატვირთად. დასრულების შემდეგ დააჭირეთ დააწკაპუნეთ არჩეული და მიჰყევით ინსტალაციის ინსტრუქციას.

მას შემდეგ რაც ყველაფერი წარმატებით გადმოწერილია, თქვენ მზად ხართ დაიწყოთ განვითარება Android- ისთვის.

ახალი Android პროექტის შექმნა

Eclipse New Project Wizard გიბიძგებთ თქვენი Android პროგრამის შექმნისას ფაილების და კოდის გენერირებისთვის, რომელიც მზად იქნება ბლოკის მარჯვნივ გასაშვებად. ეს არის სწრაფი გზა დავრწმუნდეთ, რომ ის მუშაობს და არის კარგი ამოსავალი წერტილი თქვენი აპლიკაციის შემუშავების დაწყებისას:

დასრულების დაჭერის შემდეგ, Eclipse შექმნის ახალ Android პროექტს, რომელიც მზად არის Android- ზე გასაშვებად და განვითარებისთვის. გახსოვთ თქვენ უთხარით Eclipse– ს, რომ შექმნას აქტივობა სახელად BrewClockActivity? ეს არის კოდი, რომელსაც Android იყენებს რეალურად პროგრამის გასაშვებად. გენერირებული კოდი ნაჩვენები იქნება როგორც მარტივი "Hello World" შეტყობინება.

პაკეტები

პაკეტის სახელი არის თქვენი აპლიკაციის იდენტიფიკატორი. როდესაც დროა გამოაქვეყნოთ შედეგი Android Market– ზე, ეს ID გამოყენებული იქნება აპლიკაციის განახლებების თვალყურის დევნებისთვის, ამიტომ მნიშვნელოვანია დარწმუნდეთ, რომ ეს ID უნიკალურია. მიუხედავად იმისა, რომ ჩვენ აქ ვიყენებთ სახელს com.example.brewclock, რეალური აპლიკაციისთვის უმჯობესია ავირჩიოთ com.yourcompanyname.yourapplication.

SDK ვერსიები

Min SDK ვერსია (სახელი თავისთავად მეტყველებს) არის Android– ის ყველაზე ადრეული ვერსია, რომელზეც პროგრამა იმუშავებს. Android– ის ყოველი ახალი გამოშვებით, SDK ამატებს და ცვლის სხვადასხვა მეთოდს. SDK ვერსიის არჩევისას, Android- მა (და Android Market- მა) იცის, რომ თქვენი აპლიკაცია იმუშავებს მხოლოდ Android პლატფორმის მითითებული ვერსიის და ზემოთ მოწყობილობებზე.

თქვენი აპლიკაციის გაშვება

ახლა შევეცადოთ გაუშვათ ჩვენი პროგრამა Eclipse– ში. ვინაიდან ეს არის პირველი გაშვება, Eclipse გკითხავთ რომელ პროექტზე მუშაობთ:

• აირჩიეთ გაშვება-> გაშვება ან დააჭირეთ Ctrl + F11.
• აირჩიეთ Android პროგრამა და დააწკაპუნეთ OK.

Eclipse შეეცდება გაუშვას პროგრამა Android მოწყობილობაზე. ამ ეტაპზე, თქვენ არ გაქვთ Android მოწყობილობები, ასე რომ პროექტი ჩავარდება და მოგეთხოვებათ შექმნათ ახალი Android ვირტუალური მოწყობილობა (AVD).

ვირტუალური მოწყობილობები (Android ვირტუალური მოწყობილობები)

Android ვირტუალური მოწყობილობა (AVD) ემსგავსება Android გარემოს, იქნება ეს მობილური ტელეფონი თუ პლანშეტური კომპიუტერი. თქვენ შეგიძლიათ შექმნათ იმდენი AVD, რამდენიც გსურთ, Android პლატფორმის სხვადასხვა ვერსიით. თითოეული AVD– სთვის შეგიძლიათ დააკონფიგურიროთ მოწყობილობის სხვადასხვა პარამეტრი, მიუთითოთ ფიზიკური კლავიატურის არსებობა, GP მხარდაჭერა, კამერის გარჩევადობა და ა.

პროგრამის გაშვებამდე, თქვენ უნდა შექმნათ თქვენი პირველი AVD SDK პლატფორმით (Google API, 1.6).

მოდით გავაკეთოთ ახლა:

• თუ ჯერ არ გიცდიათ პროგრამის გაშვება, დააჭირეთ Run (ან კლავიატურის მალსახმობი Ctrl + F11)
• როდესაც გაფრთხილება გამოჩნდება, დააწკაპუნეთ დიახზე, რომ შექმნათ AVD.
• დააწკაპუნეთ ახალი Android SDK და AVD მენეჯერის დიალოგში.
• დააყენეთ AVD– ს შემდეგი პარამეტრები: სახელი: Android_1.6 სამიზნე: Google API (Google Inc.) - API დონე 4 SD ბარათის ზომა: 16 MiB Skin ჩამონტაჟებული: ნაგულისხმევი (HVGA)
• დააჭირეთ შექმნა AVD.
• დახურეთ Android SDK და AVD Manager დიალოგი.

კოდის გაშვება

სცადეთ ხელახლა დაიწყოთ პროგრამა (Ctrl + F11). Eclipse ახლა ააშენებს თქვენს პროექტს და გამოუშვებს ახალ AVD- ს. დაიმახსოვრეთ, AVD მთლიანად ემსგავსება Android გარემოს და თქვენ არც კი გჭირდებათ დაკვირვება საკმაოდ ნელი ჩატვირთვის პროცესზე, როგორც ეს ხდება ნამდვილ მოწყობილობასთან. ამ მიზეზით, მას შემდეგ რაც AVD მზად იქნება წასასვლელად, უმჯობესია არ დახუროთ ფანჯარა, სანამ არ დაასრულებთ პროგრამირებას, მთელი დღის განმავლობაში.

Android განვითარება: მომხმარებლის ინტერფეისის დიზაინი

ერთ -ერთი პირველი ნაბიჯი ზოგადად ნებისმიერი პროგრამის შესაქმნელად არის დიზაინი მომხმარებლის ინტერფეისი... აქ არის ჩვენი აპლიკაციის ესკიზი:

მომხმარებელს შეეძლება დუღილის დროის დაყენება წუთებში + და - ღილაკების გამოყენებით. როდესაც ის დააწკაპუნებს დაწყებაზე, გამოთვლა დაიწყება მითითებული წუთების განმავლობაში. თუ მომხმარებელი გააუქმებს ადუღებას ღილაკზე კიდევ ერთხელ დაჭერით, დრო გაიზრდება, როდესაც ტაიმერი მიაღწევს 0 -ს.

ინტერფეისის შექმნა

Android მომხმარებლის ინტერფეისი, ან შესაფუთი, რომელიც აღწერილია XML დოკუმენტაციაში, შეგიძლიათ იხილოთ რეს / განლაგების საქაღალდეში. Eclipse– ის მიერ უკვე გენერირებული შაბლონის კოდი გამოცხადებულია res / layouts / main.xml– ში და, როგორც ხედავთ, უკვე მუშაობს ემულატორში.

Eclipse– ს აქვს საკუთარი განლაგების დიზაინის ინსტრუმენტარიუმი, რომელიც საშუალებას გაძლევთ შექმნათ გადაადგილებისა და ჩამოშვების ინტერფეისი ეკრანზე. თუმცა, ზოგჯერ უფრო ადვილია ინტერფეისის ჩაწერა XML- ში და გრაფიკული განლაგების გამოყენება შედეგების გადახედვისთვის.

მოდით გავაკეთოთ ის ახლავე main.xml– ის შეცვლით ზემოთ ესკიზის მიხედვით:

• გახსენით res / layouts / main.xml Eclipse– ში Package Explorer– დან ორმაგი დაწკაპუნებით.
• აირჩიეთ main.xml ჩანართი ეკრანის ბოლოში XML რეჟიმში გადასასვლელად.

ახლა მოდით შევცვალოთ main.xml შინაარსი შემდეგში:

# /res/layouts/main.xml

როგორც ხედავთ, Android XML– ში ბევრი ფაილია, მაგრამ ეს საშუალებას მოგცემთ გააკონტროლოთ ეკრანზე არსებული თითქმის ყველა ელემენტი.

Android– ის ერთ – ერთი ყველაზე მნიშვნელოვანი ინტერფეისის ელემენტია განლაგების კონტეინერები, როგორიცაა LinearLayout, რომელიც გამოიყენება ამ მაგალითში. ეს ელემენტები უხილავია მომხმარებლისთვის, მაგრამ მოქმედებენ როგორც კონტეინერები სხვა ელემენტებისთვის, როგორიცაა ღილაკები და TextViews.

არსებობს განლაგების განლაგების რამდენიმე ტიპი, რომელთაგან თითოეული გამოიყენება ასაშენებლად განსხვავებული ტიპებიდაგეგმვა. LinearLayout და AbsoluteLayout– ის მსგავსად, TableLayout იძლევა ქსელზე დაფუძნებულ ინტერფეისს. ამის შესახებ მეტის წაკითხვა შეგიძლიათ API დოკუმენტაციის ზოგადი ობიექტების განლაგების განყოფილებაში.

თქვენი განლაგება კოდთან არის დაკავშირებული

განლაგების შენახვის შემდეგ, სცადეთ პროგრამის გაშვება ემულატორში Ctrl + F11 დაჭერით, ან დააწკაპუნეთ Run ხატულაზე Eclipse. ახლა, "Hello World" შეტყობინების ნაცვლად, ნახავთ, რომ Android ახლა აჩვენებს პროგრამის ინტერფეისს.

თუ რომელიმე ღილაკს დააჭერთ, ისინი ანათებენ როგორც მოსალოდნელი იყო, მაგრამ ამის მიღმა არაფერს აკეთებთ. მოდით გავაგრძელოთ კოდი განლაგების ინტერფეისის შემდეგ:

# /src/com/example/brewclock/BrewClockActivity.java ... android.widget.Button იმპორტი; android.widget.TextView იმპორტი; საჯარო კლასი BrewClockActivity აფართოებს აქტივობას ( / ** თვისებები ** / დაცული ღილაკი brewAddTime; დაცული ღილაკი brewDecreaseTime; დაცული ღილაკი startBrew; დაცული TextView brewCountLabel; დაცული TextView brewTimeLabel; ...)

შემდეგი, ჩვენ შევცვლით ზარს onCreate. ეს ზარი ხდება მაშინ, როდესაც აპლიკაცია გაშვებულია Android- ზე. Eclipse– ის მიერ გენერირებულ კოდში, onCreate ქმნის აქტივობის ხედვას R.layout.main– ზე. ეს არის კოდის ხაზი, რომელიც Android- ს ავალებს განლაგების დეკოდირებას XML დოკუმენტიდა აჩვენე ის მომხმარებელს.

რესურსის ობიექტი

Android– ში R არის სპეციალური ობიექტი, რომელიც ავტომატურად იქმნება თქვენი კოდის ფარგლებში თქვენი პროექტის რესურსებზე (განლაგება, რიგები, მენიუები, ხატები ...). თითოეულ რესურსს ენიჭება საკუთარი ID. განლაგების ფაილში (იხ. ზემოთ) ეს არის @ + id XML ატრიბუტები. ჩვენ მათ გამოვიყენებთ ღილაკებისა და TextViews- ის დასაკავშირებლად ჩვენს განლაგებაში:

# /src/com/example/brewclock/BrewClockActivity.java ... საჯარო კლასი BrewClockActivity აფართოებს აქტივობას (... public void onCreate (Bundle SaveInstanceState) (super.onCreate (saveInstanceState); setContentView (R.layout.main);/ / ინტერფეისის ელემენტების დაკავშირება brewAddTime = (ღილაკი) findViewById (R.id.brew_time_up); brewDecreaseTime = (ღილაკი) findViewById (R.id.brew_time_down); startBrew = (ღილაკი) findViewById (R.id.brew_start); (TextView) findViewById (R.id.brew_count_label); brewTimeLabel = (TextView) findViewById (R.id.brew_time);))

მოვლენების "მოსმენა"

ღილაკების დაჭერის გამოსავლენად, ჩვენ უნდა განვახორციელოთ მათი მოსმენა. თქვენ შეიძლება იცნობდეთ ზარის გამცემი მსმენელის, ან გამოძახების სხვა პლატფორმებიდან, როგორიცაა Javascript / JQuery ან Rails.

Android უზრუნველყოფს მსგავს მექანიზმს მსმენელის ინტერფეისით, როგორიცაა OnClickListener, რომელიც განსაზღვრავს მეთოდებს, რომლებიც გააქტიურდება მოვლენის დროს. OnClickListener ინტერფეისი აცნობებს თქვენს აპლიკაციას, როდესაც მომხმარებელი დააჭერს ეკრანზე ან კონკრეტულ ღილაკს. გარდა ამისა, თქვენ უნდა უთხრათ თითოეულ ღილაკს ClickListener– ის შესახებ:

# /src/com/example/brewclock/BrewClockActivity.java ... // დარწმუნდით, რომ არ შემოიტანოთ // `android.content.dialoginterface.OnClickListener`. android.view.View.OnClickListener იმპორტი; საჯარო კლასი BrewClockActivity აფართოებს აქტივობას ახორციელებს OnClickListener (... public void onCreate (Bundle saveInstanceState) (... // Setup ClickListeners brewAddTime.setOnClickListener (this); brewDecreaseTime.setOnClickListener (ეს); ხილვა v) (// TODO: დაამატეთ კოდი ღილაკზე დაჭერის გასამკლავებლად))

შემდეგი, ჩვენ დავამატებთ კოდს, რომელიც მართავს ჩვენს ღილაკზე თითოეულ დაწკაპუნებას. ჩვენ ასევე დავამატებთ აქტივობის ოთხ ახალ თვისებას, რაც მომხმარებელს საშუალებას მისცემს დაადგინოს და აკონტროლოს ხარშვის დრო: რამდენი ხარშვა გაკეთდა და დაიწყო თუ არა ტაიმერი.

# /src/com/example/brewclock/BrewClockActivity.java ... საჯარო კლასი BrewClockActivity აფართოებს აქტივობას ახორციელებს OnClickListener (... დაცული int brewTime = 3; დაცული CountDownTimer brewCountDownTimer; დაცული int brewCount = 0; დაცული ლოგიკური isBrewing = .. public void onClick (View v) (if (v == brewAddTime) setBrewTime (brewTime + 1); else if (v == brewDecreaseTime) setBrewTime (brewTime -1); სხვა შემთხვევაში თუ (v == startBrew) (თუ ( isBrewing) stopBrew (); სხვაგვარად startBrew ();)))

გთხოვთ გაითვალისწინოთ, რომ ჩვენ ვიყენებთ Android– ის მიერ მოწოდებულ CountDownTimer კლასს. ეს აადვილებს მარტივი მრიცხველის შექმნას და გაშვებას და შეტყობინებების მიღებას რეგულარული ინტერვალებით, როდესაც ითვლის საწინააღმდეგოდ. თქვენ გამოიყენებთ ამას startBrew მეთოდით, წაიკითხეთ ამის შესახებ ქვემოთ.

ქვემოთ მოყვანილი მეთოდები არის სლაიდერის ქცევის მოდელები სამზარეულოს დროის დასადგენად, სამზარეულოს დაწყებისა და შეწყვეტისთვის, ასევე მრიცხველისთვის. ჩვენ ასევე ვაყენებთ brewTime და brewCount თვისებებს onCreate– ში.

კარგი პრაქტიკა იქნება ამ კოდის გადატანა ცალკე კლასიმოდელები, მაგრამ სიმარტივისთვის, ჩვენ BrewClockActivity– ს დავამატებთ კოდს:

# /src/com/example/brewclock/BrewClockActivity.java ... საჯარო კლასი BrewClockActivity ავრცელებს აქტივობას ახორციელებს OnClickListener (... public void onCreate (Bundle saveInstanceState) (... // დაადგინეთ საწყისი ხარშვის მნიშვნელობები setBrewCount (0 ); setBrewTime (3);) / ** * დააყენეთ აბსოლუტური მნიშვნელობა რაოდენობის გამოსაყენებელი წუთებისთვის. * არ აქვს ეფექტი, თუ ლუდი ამჟამად მუშაობს. * @param წუთი წუთების მომზადების წუთი. * / public void setBrewTime (int წუთი) (თუ (isBrewing) დაბრუნდება; brewTime = წუთი; თუ (brewTime< 1) brewTime = 1; brewTimeLabel.setText(String.valueOf(brewTime) + "m"); } /** * Set the number of brews that have been made, and update * the interface. * @param count The new number of brews */ public void setBrewCount(int count) { brewCount = count; brewCountLabel.setText(String.valueOf(brewCount)); } /** * Start the brew timer */ public void startBrew() { // Create a new CountDownTimer to track the brew time brewCountDownTimer = new CountDownTimer(brewTime * 60 * 1000, 1000) { @Override public void onTick(long millisUntilFinished) { brewTimeLabel.setText(String.valueOf(millisUntilFinished / 1000) + "s"); } @Override public void onFinish() { isBrewing = false; setBrewCount(brewCount + 1); brewTimeLabel.setText("Brew Up!"); startBrew.setText("Start"); } }; brewCountDownTimer.start(); startBrew.setText("Stop"); isBrewing = true; } /** * Stop the brew timer */ public void stopBrew() { if(brewCountDownTimer != null) brewCountDownTimer.cancel(); isBrewing = false; startBrew.setText("Start"); } ... }

ამ კოდის მხოლოდ Android სპეციფიკური ნაწილი ქმნის ეტიკეტის რუკებს setText მეთოდის გამოყენებით. StartBrew– ში ჩვენ ვქმნით და ვაწარმოებთ CountDownTimer– ს, რომ დავიწყოთ 1 წამიანი დათვლა, როდესაც ხარშვა / ხარშვა დასრულდება. გაითვალისწინეთ, რომ ჩვენ განვსაზღვრავთ CountDownTimer მსმენელს (onTick და onFinish). onTick დარეკილია ყოველ 1000 მილიწამში (1 წამი), ხოლო onFinish დარეკილი იქნება, როდესაც ტაიმერი ნულს მიაღწევს.

Android პროგრამირების სირთულის თავიდან აცილება

Android- ის განვითარების სახელმძღვანელოს გასაადვილებლად, მე განზრახ გამოვიყენე ეტიკეტები პირდაპირ კოდში (მაგალითად, "Brew Up!", "Start", "Stop"). სინამდვილეში, ეს არ არის კარგი პრაქტიკა, რადგან ართულებს ამ პროექტების პოვნა და შეცვლა დიდ პროექტებში.

Android უზრუნველყოფს თქვენი ტექსტის სტრიქონების R ობიექტის კოდისგან განცალკევების საშუალებას. R გაძლევთ საშუალებას განსაზღვროთ თქვენი განაცხადის ყველა სტრიქონი XML ფაილში (res / values ​​/ strings.xml), რომელზეც კოდში წვდომა შესაძლებელია მითითებით. Მაგალითად:

# /res/values/strings.xml ხარშეთ!... # /res/com/example/brewclock/BrewClockActivity.java ... brewLabel.setText (R.string.brew_up_label); ...

ახლა თუ გსურთ შეცვალოთ Brew Up! სხვა რამ, თქვენ უნდა შეცვალოთ იგი ერთხელ strings.xml ფაილში. თუ თქვენი აპლიკაცია შეიცავს ათეულობით კოდის ფაილს, ერთ ადგილას წერას დიდი აზრი აქვს!

BrewClock- ის შემოწმება

ჩვენ დავამთავრეთ კოდის წერა და დროა აპლიკაცია "გამოვცადოთ". დააჭირეთ "გაშვებას" ან Ctrl + F11 ემულატორში BrewClock გასაშვებად. თუ ყველაფერი კარგად წავიდა, თქვენ უნდა ნახოთ კონფიგურაციის ინტერფეისი და მზად ხართ ჩაის დასალევად! სცადეთ დაადგინოთ ხარშვის სხვადასხვა დრო და დააწკაპუნეთ დაწყება დასათვლელად.

Შემაჯამებელი

Android განვითარების ამ სწრაფ შესავალში თქვენ გადმოწერეთ და დააინსტალირეთ Android SDK და Eclipse Android Development Tools (ADT) მოდული. თქვენ შექმენით ემულატორი ან ვირტუალური მოწყობილობა თქვენი აპლიკაციების შესამოწმებლად. თქვენ ასევე შექმენით სამუშაო Android პროგრამა, რომელიც ხაზს უსვამს უამრავ ძირითად კონცეფციას. , რომელსაც გამოიყენებთ მომავალი Android პროგრამების შემუშავებისას.

ვიმედოვნებთ, რომ ეს გააღვივებს თქვენს მადას მობილური აპლიკაციების შესაქმნელად და ექსპერიმენტებისთვის ამ საინტერესო სფეროში. Android გვთავაზობს პროგრამების წერის დიდ რაოდენობას მიმდინარე და მომავალი მობილური მოწყობილობებისთვის. თუ თქვენ უკვე დაწერეთ სამუშაო პროგრამა ამ პლატფორმისთვის, არ დაგავიწყდეთ შეგვატყობინოთ კომენტარებში!