ზოგჯერ ანდროიდის ზოგიერთი აპლიკაცია რატომღაც არ უხდება მომხმარებელს. ამის მაგალითია შემაშფოთებელი რეკლამები. და ეს ასეც ხდება - პროგრამაში ყველა კარგად ერკვევა, მაგრამ მასში მხოლოდ თარგმანია ან მრუდი, ან საერთოდ არ არსებობს. ან, მაგალითად, პროგრამა საცდელია, მაგრამ სრული ვერსიის მიღების საშუალება არ არსებობს. როგორ შევცვალოთ სიტუაცია?
შესავალი
ამ სტატიაში ვისაუბრებთ იმაზე, თუ როგორ უნდა დაშალოთ APK აპლიკაციით, გადავხედოთ მის შიდა სტრუქტურას, დავშალოთ და დავაკომპილოთ ბაიტეკოდი, ასევე შევეცდებით რამდენიმე ცვლილება შევიტანოთ აპლიკაციებში, რამაც შეიძლება მოგვიტანოს ესა თუ ის სარგებელი.
ამ ყველაფრის დამოუკიდებლად გასაკეთებლად, დაგჭირდებათ Java ენის მინიმუმ საბაზისო ცოდნა, რომელშიც იწერება Android აპლიკაციები და XML ენა, რომელიც ყველგან გამოიყენება Android-ში - თავად აპლიკაციის აღწერიდან და მისი წვდომის უფლებების სტრიქონების შენახვამდე. რომელიც გამოჩნდება ეკრანზე. თქვენ ასევე დაგჭირდებათ სპეციალიზებული კონსოლის პროგრამული უზრუნველყოფის დამუშავების უნარი.
მაშ, რა არის APK პაკეტი, რომელშიც განაწილებულია აბსოლუტურად ყველა პროგრამა Android-ისთვის?
აპლიკაციის დეკომპილაცია
სტატიაში ჩვენ მხოლოდ დაშლილი აპლიკაციის კოდით ვიმუშავეთ, თუმცა, თუ უფრო სერიოზულ ცვლილებებს შეიტანთ დიდ აპლიკაციებში, გაცილებით რთული იქნება smali კოდის გაგება. საბედნიეროდ, ჩვენ შეგვიძლია dex კოდის დეკომპილირება Java-ის კოდში, რომელიც მართალია ორიგინალური არ არის და არ არის კომპილირებული, მაგრამ ბევრად უფრო ადვილია წაკითხვა და აპლიკაციის ლოგიკის გაგება. ამისათვის ჩვენ გვჭირდება ორი ინსტრუმენტი:
- dex2jar - Dalvik bytecode-ის თარჯიმანი JVM bytecode-ზე, რომლის საფუძველზეც შეგვიძლია მივიღოთ Java კოდი;
- jd-gui არის თავად დეკომპილერი, რომელიც საშუალებას გაძლევთ მიიღოთ იკითხებადი Java კოდი JVM bytecode-დან. გარდა ამისა, შეგიძლიათ გამოიყენოთ Jad (www.varanecas.com/jad); მიუხედავად იმისა, რომ ის საკმაოდ ძველია, ზოგიერთ შემთხვევაში ის წარმოქმნის უფრო წასაკითხ კოდს, ვიდრე Jd-gui.
ისინი უნდა იქნას გამოყენებული ასე. პირველ რიგში, ჩვენ ვიწყებთ dex2jar-ს, არგუმენტად აკონკრეტებთ გზას apk პაკეტისკენ:
%dex2jar.sh mail.apk
შედეგად, mail.jar Java პაკეტი გამოჩნდება მიმდინარე დირექტორიაში, რომელიც უკვე შეიძლება გაიხსნას jd-gui-ში Java კოდის სანახავად.
APK პაკეტების მოწყობა და მათი მიღება
ანდროიდის აპლიკაციის პაკეტი არსებითად ჩვეულებრივი ZIP ფაილია, რომელიც არ საჭიროებს რაიმე სპეციალურ ინსტრუმენტებს შინაარსის სანახავად და გასახსნელად. საკმარისია არქივატორი - 7zip Windows-ისთვის ან კონსოლის unzip Linux-ში. მაგრამ ეს ეხება შეფუთვას. Რა არის შიგნით? შიგნით, ზოგადად გვაქვს შემდეგი სტრუქტურა:
- META-INF/- შეიცავს აპლიკაციის ციფრულ სერთიფიკატს, რომელიც ადასტურებს მის შემქმნელს და პაკეტის ფაილების ჩეკს;
- res/ - სხვადასხვა რესურსი, რომელსაც აპლიკაცია იყენებს თავის მუშაობაში, როგორიცაა სურათები, ინტერფეისის დეკლარაციული აღწერა და სხვა მონაცემები;
- AndroidManifest.xml- განაცხადის აღწერა. ეს მოიცავს, მაგალითად, საჭირო ნებართვების ჩამონათვალს, Android-ის საჭირო ვერსიას და ეკრანის საჭირო გარჩევადობას;
- კლასები.dex- შედგენილი განაცხადის ბაიტეკოდი Dalvik ვირტუალური მანქანისთვის;
- რესურსები.arsc- ასევე რესურსები, მაგრამ სხვა სახის - კერძოდ, სტრიქონები (დიახ, ეს ფაილი შეიძლება გამოყენებულ იქნას რუსიფიკაციისთვის!).
ჩამოთვლილი ფაილები და დირექტორიები არის, თუ არა ყველა, მაშინ, შესაძლოა, APK-ების დიდ უმრავლესობაში. თუმცა, არის კიდევ რამდენიმე ნაკლებად გავრცელებული ფაილი/ცნობარი, რომელიც უნდა აღინიშნოს:
- აქტივები- რესურსების ანალოგი. მთავარი განსხვავება ისაა, რომ რესურსზე წვდომისთვის საჭიროა იცოდეთ მისი იდენტიფიკატორი, ხოლო აქტივების სიის დინამიურად მიღება შესაძლებელია აპლიკაციის კოდში AssetManager.list() მეთოდის გამოყენებით;
- lib- მშობლიური Linux ბიბლიოთეკები დაწერილი NDK (Native Development Kit) დახმარებით.
ამ დირექტორიას იყენებენ თამაშების მწარმოებლები, სადაც ისინი ათავსებენ თავიანთ სათამაშო ძრავას C/C++-ზე დაწერილი, ასევე მაღალი ხარისხის აპლიკაციების შემქმნელების მიერ (მაგალითად, Google Chrome). ესმოდა მოწყობილობა. მაგრამ როგორ მივიღოთ ინტერესის განაცხადის პაკეტის ფაილი? იმის გამო, რომ შეუძლებელია მოწყობილობიდან APK ფაილების მიღება rooting-ის გარეშე (ისინი არიან / data / app დირექტორიაში) და rooting ყოველთვის არ არის მიზანშეწონილი, აპლიკაციის ფაილის კომპიუტერში გადატანის მინიმუმ სამი გზა არსებობს:
- APK Downloader გაფართოება Chrome-ისთვის;
- რეალური APK Leecher აპლიკაცია;
- სხვადასხვა ფაილების ჰოსტინგი და warezniki.
რომელი გამოვიყენოთ გემოვნების საკითხია; ჩვენ გვირჩევნია გამოვიყენოთ ცალკეული აპლიკაციები, ამიტომ აღვწერთ Real APK Leecher-ის გამოყენებას, მით უმეტეს, რომ ის Java-შია დაწერილი და, შესაბამისად, იმუშავებს თუნდაც Windows-ში, თუნდაც nix-ში.
პროგრამის დაწყების შემდეგ თქვენ უნდა შეავსოთ სამი ველი: ელფოსტა, პაროლი და მოწყობილობის ID - და აირჩიეთ ენა. პირველი ორი არის თქვენი Google ანგარიშის ელექტრონული ფოსტა და პაროლი, რომელსაც იყენებთ მოწყობილობაზე. მესამე არის მოწყობილობის ID და მისი მიღება შეგიძლიათ აკრიფეთ კოდის აკრეფით # #8255## და შემდეგ იპოვნეთ ხაზი მოწყობილობის ID. შევსებისას თქვენ უნდა შეიყვანოთ მხოლოდ ID ანდროიდის პრეფიქსის გარეშე.
შევსების და შენახვის შემდეგ ხშირად ჩნდება შეტყობინება „შეცდომა სერვერთან დაკავშირებისას“. მას არაფერი აქვს საერთო Google Play-სთან, ასე რომ, თავისუფლად უგულებელყოფთ მას და მოძებნეთ თქვენთვის საინტერესო პაკეტები.
განხილვა და მოდიფიკაცია
ვთქვათ, იპოვნეთ თქვენთვის საინტერესო პაკეტი, ჩამოტვირთეთ, ამოშალეთ... და როცა ცდილობდით ზოგიერთი XML ფაილის ნახვას, გაგიკვირდათ, როცა აღმოაჩინეთ, რომ ფაილი არ არის ტექსტური ფაილი. როგორ ხდება მისი დეკომპილი და ზოგადად პაკეტებთან მუშაობა? ნამდვილად საჭიროა SDK-ის დაყენება? არა, თქვენ არ გჭირდებათ SDK-ის დაყენება. სინამდვილეში, APK პაკეტების ამოხსნის, შეცვლისა და შეფუთვის ყველა ნაბიჯისთვის საჭიროა შემდეგი ინსტრუმენტები:
- ZIP არქივატორიგასახსნელად და შესაფუთად;
- პატარა- Dalvik ვირტუალური მანქანის ბაიტეკოდის ასამბლერი/დემონტაჟი (code.google.com/p/smali);
- აპტ- რესურსების შეფუთვის ინსტრუმენტი (ნაგულისხმევად, რესურსები ინახება ორობითი ფორმით აპლიკაციის მუშაობის ოპტიმიზაციისთვის). მოყვება Android SDK, მაგრამ მისი მიღება შესაძლებელია ცალკე;
- ხელმომწერი- ინსტრუმენტი შეცვლილი პაკეტის ციფრული ხელმოწერისთვის (bit.ly/Rmrv4M).
თქვენ შეგიძლიათ გამოიყენოთ ყველა ეს ინსტრუმენტი ცალკე, მაგრამ ეს მოუხერხებელია, ამიტომ უმჯობესია გამოიყენოთ უფრო მაღალი დონის პროგრამული უზრუნველყოფა, რომელიც აგებულია მათ საფუძველზე. თუ თქვენ მუშაობთ Linux-ზე ან Mac OS X-ზე, არის ინსტრუმენტი სახელწოდებით apktool. ის საშუალებას გაძლევთ გახსნათ რესურსები თავდაპირველ ფორმაში (მათ შორის ორობითი XML და arsc ფაილები), აღადგინოთ პაკეტი შეცვლილი რესურსებით, მაგრამ მან არ იცის როგორ მოაწეროს ხელი პაკეტებს, ასე რომ თქვენ მოგიწევთ ხელმომწერის პროგრამის ხელით გაშვება. იმისდა მიუხედავად, რომ პროგრამა დაწერილია ჯავაში, მისი ინსტალაცია საკმაოდ არასტანდარტულია. ჯერ თავად უნდა მიიღოთ jar ფაილი:
$ cd /tmp $ wget http://bit.ly/WC3OCz $ tar -xjf apktool1.5.1.tar.bz2
$ wget http://bit.ly/WRjEc7 $ tar -xjf apktool-install-linux-r05-ibot.tar.bz2
$ mv apktool.jar ~/bin $ mv apktool-install-linux-r05-ibot/* ~/bin $ export PATH=~/bin:$PATH
თუ თქვენ მუშაობთ Windows-ზე, მაშინ არის მისთვის შესანიშნავი ინსტრუმენტი სახელწოდებით Virtual Ten Studio, რომელიც ასევე აგროვებს ყველა ამ ინსტრუმენტს (თავად apktool-ის ჩათვლით), მაგრამ CLI ინტერფეისის ნაცვლად, მომხმარებელს აძლევს ინტუიციურ გრაფიკულ ინტერფეისს, რომლითაც შეასრულეთ შეფუთვის, დაშლისა და დეკომპილაციის ოპერაციები რამდენიმე დაწკაპუნებით. ეს ინსტრუმენტი არის Donation-ware, ანუ ფანჯრები ხანდახან ჩნდება ლიცენზიის მოპოვების წინადადებით, მაგრამ ეს, საბოლოო ჯამში, შეიძლება მოითმინოს. აზრი არ აქვს მის აღწერას, რადგან ინტერფეისის გაგება რამდენიმე წუთში შეგიძლიათ. მაგრამ apktool, მისი კონსოლის ბუნებიდან გამომდინარე, უფრო დეტალურად უნდა იყოს განხილული.
განიხილეთ apktool პარამეტრები. მოკლედ, არსებობს სამი ძირითადი ბრძანება: d (decode), b (build) და if (install frame). თუ პირველი ორი ბრძანებით ყველაფერი ნათელია, მაშინ რას აკეთებს მესამე, პირობითი ოპერატორი? ის ხსნის მითითებულ UI ჩარჩოს, რომელიც საჭიროა სისტემის პაკეტის ამოკვეთისას.
განვიხილოთ პირველი ბრძანების ყველაზე საინტერესო ვარიანტები:
- -ს- არ დაშალოთ dex ფაილები;
- -რ- არ ამოალაგოთ რესურსები;
- -ბ- არ ჩადოთ გამართვის ინფორმაცია dex ფაილის დაშლის შედეგებში;
- --ჩარჩო-გზა- გამოიყენეთ მითითებული UI ჩარჩო ჩაშენებული apktool-ის ნაცვლად. ახლა განიხილეთ b ბრძანების რამდენიმე ვარიანტი:
- -ვ- იძულებითი შეკრება ცვლილებების შემოწმების გარეშე;
- -ა- მიუთითეთ გზა aapt-მდე (აპკ არქივის შესაქმნელად ინსტრუმენტი), თუ რაიმე მიზეზით გსურთ მისი გამოყენება სხვა წყაროდან.
apktool-ის გამოყენება ძალიან მარტივია, თქვენ მხოლოდ უნდა მიუთითოთ ერთ-ერთი ბრძანება და APK-ის გზა, მაგალითად:
$ apktool d mail.apk
ამის შემდეგ, ყველა ამოღებული და დაშლილი პაკეტის ფაილი გამოჩნდება ფოსტის დირექტორიაში.
მომზადება. გამორთეთ რეკლამები
თეორია, რა თქმა უნდა, კარგია, მაგრამ რატომ არის საჭირო, თუ არ ვიცით რა ვუყოთ შეუფუთავ პაკეტს? შევეცადოთ გამოვიყენოთ თეორია ჩვენივე სარგებლისთვის, კერძოდ, შევცვლით ზოგიერთ პროგრამულ უზრუნველყოფას ისე, რომ არ გვიჩვენოს რეკლამები. მაგალითად, იყოს ვირტუალური ჩირაღდანი - ვირტუალური ჩირაღდანი. ჩვენთვის ეს პროგრამა შესანიშნავია, რადგან ის სავსეა შემაშფოთებელი რეკლამებით და საკმარისად მარტივია, რომ არ დაიკარგოს კოდის ველურში.
ასე რომ, ერთ-ერთი ზემოაღნიშნული მეთოდის გამოყენებით, ჩამოტვირთეთ აპლიკაცია მარკეტიდან. თუ გადაწყვეტთ Virtuous Ten Studio-ს გამოყენებას, უბრალოდ გახსენით APK ფაილი აპლიკაციაში და გახსენით იგი, რისთვისაც შექმენით პროექტი (File -> New project), შემდეგ აირჩიეთ Import File პროექტის კონტექსტური მენიუდან. თუ თქვენი არჩევანი დაეცა apktool-ზე, მაშინ საკმარისია შეასრულოთ ერთი ბრძანება:
$ apktool d com.kauf.particle.virtualtorch.apk
ამის შემდეგ, ფაილის ხე გამოჩნდება com.kauf.particle.virtualtorch დირექტორიაში, წინა განყოფილებაში აღწერილის მსგავსი, მაგრამ dex ფაილების და apktool.yml ფაილის ნაცვლად დამატებითი smali დირექტორია. პირველი შეიცავს აპლიკაციის შესრულებადი dex ფაილის დაშლილ კოდს, მეორე შეიცავს სერვისის ინფორმაციას, რომელიც საჭიროა apktool-ის მიერ პაკეტის უკან აწყობისთვის.
პირველი ადგილი, რომელიც უნდა ვეძებოთ, რა თქმა უნდა, არის AndroidManifest.xml. და აქ ჩვენ მაშინვე ვხვდებით შემდეგ ხაზს:
ადვილი მისახვედრია, რომ ის არის პასუხისმგებელი აპლიკაციისთვის ინტერნეტის გამოყენების ნებართვის მინიჭებაზე. ფაქტობრივად, თუ ჩვენ უბრალოდ გვინდა რეკლამებისგან თავის დაღწევა, დიდი ალბათობით საკმარისი იქნება აპლიკაციის ინტერნეტიდან აკრძალვა. ვცადოთ ამის გაკეთება. წაშალეთ მითითებული ხაზი და სცადეთ პროგრამის შედგენა apktool-ის გამოყენებით:
$ apktool b com.kauf.particle.virtualtorch
შედეგად მიღებული APK ფაილი გამოჩნდება com.kauf.particle.virtualtorch/build/ დირექტორიაში. თუმცა, მისი ინსტალაცია შეუძლებელია, რადგან მას არ აქვს ციფრული ხელმოწერა და ფაილების შემოწმება (მას უბრალოდ არ აქვს META-INF/ დირექტორია). ჩვენ უნდა მოვაწეროთ პაკეტს apk-signer უტილიტა. Დაიწყო. ინტერფეისი შედგება ორი ჩანართისგან - პირველზე (Key Generator) ჩვენ ვქმნით გასაღებებს, მეორეზე (APK Signer) ვაწერთ ხელს. ჩვენი პირადი გასაღების შესაქმნელად, შეავსეთ შემდეგი ველები:
- სამიზნე ფაილი- keystore გამომავალი ფაილი; ის ჩვეულებრივ ინახავს ერთ წყვილ გასაღებს;
- პაროლიდა დაადასტურეთ- პაროლი შენახვისთვის;
- მეტსახელი- გასაღების დასახელება საცავში;
- მეტსახელის პაროლიდა დაადასტურეთ- საიდუმლო გასაღების პაროლი;
- მოქმედების ვადა- მოქმედების ვადა (წლები). ნაგულისხმევი მნიშვნელობა ოპტიმალურია.
დანარჩენი ველები, ზოგადად, არჩევითია - მაგრამ თქვენ უნდა შეავსოთ მინიმუმ ერთი.
გაფრთხილება
apk-signer-ით აპლიკაციის გასაფორმებლად, თქვენ უნდა დააინსტალიროთ Android SDK და მიუთითოთ მისი სრული გზა აპლიკაციის პარამეტრებში.
ყველა ინფორმაცია მოცემულია მხოლოდ საინფორმაციო მიზნებისთვის. არც რედაქტორები და არც ავტორი არ არიან პასუხისმგებელი ამ სტატიის მასალებით მიყენებულ შესაძლო ზიანს.
ახლა თქვენ შეგიძლიათ ხელი მოაწეროთ APK-ს ამ გასაღებით. APK Signer ჩანართზე აირჩიეთ ახლად გენერირებული ფაილი, შეიყვანეთ მისთვის პაროლი, გასაღების მეტსახელი და პაროლი, შემდეგ იპოვეთ APK ფაილი და თამამად დააწკაპუნეთ ღილაკზე "ხელმოწერა". თუ ყველაფერი კარგად წავა, პაკეტს მოეწერება ხელი.
ინფორმაცია
ვინაიდან ჩვენ ხელი მოვაწერეთ პაკეტს ჩვენივე გასაღებით, ის ეწინააღმდეგება თავდაპირველ აპლიკაციას, რაც ნიშნავს, რომ როდესაც ვცდილობთ პროგრამული უზრუნველყოფის განახლებას ბაზრის მეშვეობით, მივიღებთ შეცდომას.
მხოლოდ მესამე მხარის პროგრამულ უზრუნველყოფას სჭირდება ციფრული ხელმოწერა, ასე რომ, თუ თქვენ ცვლით სისტემურ აპლიკაციებს, რომლებიც დაინსტალირებულია მათი კოპირებით /system/app/ დირექტორიაში, მაშინ არ გჭირდებათ მათი ხელმოწერა.
ამის შემდეგ პაკეტს სმარტფონზე ვყრით, ვაინსტალირებთ და ვაწარმოებთ. Voila, რეკლამა გაქრა! თუმცა, ამის ნაცვლად, გამოჩნდა შეტყობინება, რომ ჩვენ არ გვაქვს ინტერნეტი ან არ გვაქვს შესაბამისი ნებართვები. თეორიულად, ეს შეიძლება იყოს საკმარისი, მაგრამ შეტყობინება გამაღიზიანებლად გამოიყურება და, მართალი გითხრათ, ჩვენ უბრალოდ გაგვიმართლა სულელური აპლიკაცია. კარგად დაწერილი პროგრამული უზრუნველყოფა, სავარაუდოდ, დააზუსტებს მის რწმუნებათა სიგელებს ან შეამოწმებს ინტერნეტ კავშირს და წინააღმდეგ შემთხვევაში უბრალოდ უარს იტყვის დაწყებაზე. როგორ უნდა იყოს ამ შემთხვევაში? რა თქმა უნდა, შეცვალეთ კოდი.
როგორც წესი, აპლიკაციის ავტორები ქმნიან სპეციალურ კლასებს რეკლამებისა და ამ კლასების გამოძახების მეთოდების საჩვენებლად აპლიკაციის ან მისი ერთ-ერთი „აქტივობის“ დროს (მარტივი სიტყვებით, აპლიკაციის ეკრანები). შევეცადოთ ვიპოვოთ ეს კლასები. ჩვენ მივდივართ smali დირექტორიაში, შემდეგ com-ში (org არის მხოლოდ ღია გრაფიკული ბიბლიოთეკა cocos2d), შემდეგ kauf (ზუსტად იქ, რადგან ეს არის დეველოპერის სახელი და მთელი მისი კოდი იქ არის) - და აი, მარკეტინგული დირექტორია. შიგნით ვპოულობთ ფაილების თაიგულს smali გაფართოებით. ეს არის კლასები და მათგან ყველაზე საყურადღებოა Ad.smali კლასი, რომლის სახელწოდებითაც ადვილი მისახვედრია, რომ ის აჩვენებს რეკლამებს.
ჩვენ შეგვეძლო შევცვალოთ მისი მუშაობის ლოგიკა, მაგრამ ბევრად უფრო ადვილი იქნებოდა ზარების სულელურად ამოღება მის რომელიმე მეთოდზე თავად აპლიკაციიდან. აქედან გამომდინარე, ჩვენ გავდივართ მარკეტინგის დირექტორიაში და მივდივართ მეზობელ ნაწილაკების დირექტორიაში, შემდეგ კი ვირტუალურ ტორშზე. MainActivity.smali ფაილი აქ განსაკუთრებულ ყურადღებას იმსახურებს. ეს არის სტანდარტული ანდროიდის კლასი, რომელიც გენერირებულია Android SDK-ით და დაყენებულია აპლიკაციის შესვლის წერტილად (C-ში მთავარი ფუნქციის ანალოგიურად). გახსენით ფაილი რედაქტირებისთვის.
შიგნით არის smali კოდი (ლოკალური ასამბლერი). ის საკმაოდ დამაბნეველი და ძნელად იკითხება მისი დაბალი დონის გამო, ამიტომ ჩვენ არ შევისწავლით მას, არამედ უბრალოდ ვიპოვით კოდში რეკლამის კლასის ყველა ხსენებას და კომენტარს გავაკეთებთ. ჩვენ ვატარებთ სტრიქონში "რეკლამა" ძიებაში და მივდივართ სტრიქონში 25:
საველე პირადი რეკლამა:Lcom/kauf/მარკეტინგი/რეკლამა;
აქ იქმნება ველი რეკლამა Ad კლასის ობიექტის შესანახად. კომენტარს ვაკეთებთ ხაზის წინ ### ნიშნის დაყენებით. ჩვენ ვაგრძელებთ ძებნას. ხაზი 423:
ახალი ინსტანციის v3, Lcom/kauf/მარკეტინგი/რეკლამა;
სწორედ აქ იქმნება ობიექტი. კომენტარს ვაკეთებთ. ჩვენ ვაგრძელებთ ძიებას და ვპოულობთ 433, 435, 466, 468, 738, 740, 800 და 802 ხაზებში რეკლამის კლასის მეთოდებს. კომენტარს ვაკეთებთ. გამოიყურებოდეს, რომ ეს არის. ჩვენ ვზოგავთ. ახლა საჭიროა პაკეტის აწყობა და შემოწმება მისი შესრულებისა და რეკლამის არსებობისთვის. ექსპერიმენტის სიწმინდისთვის, ჩვენ ვაბრუნებთ AndroidManifest.xml-დან ამოღებულ ხაზს, ვაგროვებთ პაკეტს, ხელს ვაწერთ მას და დავაინსტალირებთ.
ჩვენი ზღვის გოჭი. ხილული რეკლამა 
ოპ-პა! რეკლამა გაქრა მხოლოდ აპლიკაციის მუშაობის დროს, მაგრამ დარჩა მთავარ მენიუში, რომელსაც ვხედავთ პროგრამის გაშვებისას. ასე რომ, დაელოდეთ, მაგრამ შესვლის წერტილი არის MainActivity კლასი და რეკლამა გაქრა აპლიკაციის მუშაობის დროს, მაგრამ დარჩა მთავარ მენიუში, ასე რომ, შესვლის წერტილი განსხვავებულია? ნამდვილი შესვლის წერტილის გამოსავლენად, ჩვენ ხელახლა ვხსნით AndroidManifest.xml ფაილს. დიახ, ის შეიცავს შემდეგ ხაზებს:
ისინი გვეუბნებიან (და რაც მთავარია, ანდროიდს), რომ აქტივობა სახელწოდებით Start უნდა დაიწყოს android.intent.action.MAIN მიზნის (მოვლენის) გენერირების პასუხად android.intent.category.LAUNCHER კატეგორიიდან. ეს მოვლენა წარმოიქმნება, როდესაც თქვენ შეეხებით აპლიკაციის ხატულას გამშვებში, ასე რომ ის განსაზღვრავს შესვლის წერტილს, კერძოდ Start კლასს. სავარაუდოდ, პროგრამისტმა ჯერ დაწერა აპლიკაცია მთავარი მენიუს გარეშე, რომლის შესვლის წერტილი იყო სტანდარტული MainActivity კლასი, შემდეგ დაამატა ახალი ფანჯარა (აქტივობა), რომელიც შეიცავს მენიუს და აღწერა Start კლასში, და ხელით გააკეთა ჩანაწერად. წერტილი.
ვხსნით ფაილს Start.smali და ისევ ვეძებთ ხაზს "Ad", 153 და 155 სტრიქონებში ვხვდებით FirstAd კლასის ხსენებას. ის ასევე არის საწყის კოდში და, სახელწოდებით თუ ვიმსჯელებთ, ის პასუხისმგებელია მთავარ ეკრანზე რეკლამის ჩვენებაზე. ჩვენ უფრო შორს ვიყურებით, იქმნება FirstAd კლასის ინსტანცია და ინტენტი, ამ მაგალითთან დაკავშირებული კონტექსტის მიხედვით, შემდეგ კი label cond_10, რომელზეც პირობითი გადასვლა ხორციელდება ზუსტად კლასის ინსტანციის შექმნამდე. :
If-ne p1, v0, :cond_10 .ხაზი 74 new-instance v0, Landroid/content/Intent; ... :cond_10
სავარაუდოდ, პროგრამა რატომღაც შემთხვევით ითვლის, საჭიროა თუ არა რეკლამის ჩვენება მთავარ ეკრანზე და თუ არა, პირდაპირ გადადის cond_10-ზე. კარგი, მოდით გავამარტივოთ მისი ამოცანა და შევცვალოთ პირობითი გადასვლა უპირობოთი:
#if-ne p1, v0, :cond_10 goto:cond_10
კოდში აღარ არის ნახსენები FirstAd-ის შესახებ, ამიტომ ჩვენ ვხურავთ ფაილს და ხელახლა ვაწყობთ ჩვენს ვირტუალურ ჩირაღდნებს apktool-ის გამოყენებით. დააკოპირეთ სმარტფონზე, დააინსტალირეთ, გაუშვით. Voila, ყველა რეკლამა გაქრა, გილოცავთ ყველას.
შედეგები
ეს სტატია მხოლოდ მოკლე შესავალია Android აპლიკაციების გახსნისა და მოდიფიცირების მეთოდების შესახებ. ბევრი პრობლემა დარჩა კულისებში, როგორიცაა დაცვის მოხსნა, ბუნდოვანი კოდის ანალიზი, აპლიკაციის რესურსების თარგმნა და ჩანაცვლება, ასევე Android NDK-ის გამოყენებით დაწერილი აპლიკაციების შეცვლა. თუმცა საბაზისო ცოდნის ქონა, ამ ყველაფრის გაგება მხოლოდ დროის საკითხია.
ბოლო განახლება: 10/30/2015
აპლიკაციის შექმნის, ტესტირებისა და გამართვის შემდეგ, შეგვიძლია დავიწყოთ მისი გამოქვეყნება. პუბლიკაციის არსი არის ფაილის შექმნა გაფართოებით .აპკ, რომელიც წარმოადგენს აპლიკაციას და მის შემდგომ განთავსებას Google Play Market-ში ან სხვა გარე საიტებზე. ნაგულისხმევად, აპლიკაციის გამართვისა და შექმნის პროცესში, apk ფაილი უკვე შექმნილია და მისი პოვნა შესაძლებელია პროექტის საქაღალდეში გზაზე. პროექტის_სახელი\app\build\outputs\apk. ნაგულისხმევად, ფაილი დასახელებულია app-debug.apkდა წარმოადგენს გამართვის ვერსიას.
მაგრამ ამ ფაილის სრული გამოქვეყნებისთვის შეიძლება საკმარისი არ იყოს. და ჩვენ ჯერ კიდევ გვჭირდება პროექტის მომზადება გამოსაშვებად. ამისათვის მიუთითეთ ელემენტის manifest ფაილში
გარდა ამისა, ამ ეტაპზე შეგიძლიათ დააყენოთ აპლიკაციის ხატულა, რომელიც გამოჩნდება გაჯეტის მთავარ ეკრანზე, აპლიკაციის სახელი (ატრიბუტი android: label ელემენტზე) და ასევე შეგიძლიათ დააყენოთ სალიცენზიო ხელშეკრულება.
manifest ფაილმა ასევე უნდა განსაზღვროს პაკეტის სახელი (ელემენტის პაკეტის ატრიბუტი
უფრო მეტიც, თუ java კოდის ფაილებში, ფაილის დასაწყისში პაკეტის სახელი ასევე უნდა შეესაბამებოდეს განაცხადის პაკეტს.
მოთხოვნების დაყენება
თქვენ ასევე შეგიძლიათ დააყენოთ API მოთხოვნები წინასწარ გამოშვების ფაზაში. მაგალითად, ჩვენს აპლიკაციას აქვს Android OS-ის გარკვეული მინიმალური ვერსია, ასე რომ ჩვენ შეგვიძლია დავაყენოთ შესაბამისი ატრიბუტები მანიფესტის ფაილში არსებულ ელემენტზე.
android:minSdkVersion - Android-ის მინიმალური ვერსია
android:targetSdkVersion - ოპტიმალური API ვერსია
android:maxSdkVersion - სისტემის მაქსიმალური ვერსია
მაგალითად, ვთქვათ Jelly Beans-ის მინიმალური ვერსია არის 4.1.2, ხოლო ოპტიმალური ვერსია არის KitKat 4.4.4:
განაცხადის ხელმოწერა
როდესაც ყველაფერი მზად იქნება, ანდროიდის აპლიკაციას უნდა მოაწეროთ ხელი სერტიფიკატით, რომლის წყალობითაც შესაძლებელია აპლიკაციის ავტორის იდენტიფიცირება. როდესაც აპლიკაციას ვამოწმებთ მოწყობილობაზე Android Studio-ის საშუალებით დაინსტალირებით, ის ავტომატურად ხელმოწერილია. მაგრამ გამოშვების ვერსიის შესაქმნელად, ჩვენ გვჭირდება მოქმედებების დამატებითი სერია.
სერტიფიკატის შექმნისას გაითვალისწინეთ, რომ აპლიკაციის განახლებისას სისტემა შეადარებს ძველი და ახალი ვერსიების სერთიფიკატებს. და განახლება მოხდება, თუ ორივე ვერსიის სერთიფიკატები ემთხვევა. მაგრამ თუ ახალ ვერსიაზე ხელმოწერილია ახალი სერტიფიკატი, მაშინ აპლიკაცია განიხილება, როგორც სრულიად ახალი, არ არის დაკავშირებული ძველ ვერსიასთან და წარმოადგენს სრულიად განსხვავებულ აპლიკაციას. ამ შემთხვევაში, მისი ინსტალაციისთვის, ახალ ვერსიას უნდა ჰქონდეს პაკეტის განსხვავებული სახელი, ვიდრე ძველი.
ჯერ Android Studio-ში აირჩიეთ Build -> Generate Signed APK მენიუდან. ეს გახსნის ოსტატის ფანჯარას:
დააწკაპუნეთ ღილაკზე Create new.... ამის შემდეგ გაიხსნება გასაღების შექმნის ფანჯარა:
შეიყვანეთ გზა ქსელის სერტიფიკატის ფაილის შესაქმნელად, გასაღების შენახვის ბილიკის ველში. თუ მითითებული საქაღალდე არ არსებობს, შექმენით იგი ან განსაზღვრეთ არსებული საქაღალდე.
პაროლი/დადასტურების ველში მიუთითეთ პაროლი.
მიუთითეთ მეტსახელი Alias ველში. შეგიძლიათ დაასახელოთ თვითნებური სახელი.
სახელი და გვარი ველში შეიყვანეთ სახელი და გვარი. შემდეგ ჩვენ ვწერთ ერთეულს, ორგანიზაციას, ქალაქს, ქვეყნის და ქვეყნის კოდს.
დასასრულს დააწკაპუნეთ OK.
ამის შემდეგ, პირველი ფანჯარა ავტომატურად განახლდება:
საბოლოო ფანჯარა გვიჩვენებს გზას დირექტორიაში, სადაც ხელმოწერილი apk აპლიკაცია განთავსდება გამოშვების ვერსიაში. დააწკაპუნეთ Finish-ზე.
ახლა, მითითებულ გზაზე, შეგიძლიათ იპოვოთ ხელმოწერილი apk, რომელსაც ექნება სახელი app-release.apk:
ჩვენ შეგვიძლია დავარქვათ ფაილი, შევინარჩუნოთ მისი გაფართოება და ავტვირთოთ ის Play Market-ზე ან ნებისმიერ საიტზე, ან გადმოვწეროთ პირდაპირ თქვენს მობილურ მოწყობილობაზე. თქვენს ტელეფონზე / ტაბლეტზე ჩამოტვირთვის შემდეგ, უბრალოდ დააწკაპუნეთ მასზე და სტანდარტული პაკეტის ინსტალერის გამოყენებით, აპლიკაცია დაინსტალირდება. მართალია, აქვე უნდა გავითვალისწინოთ, რომ თუ აპლიკაციას არა Play Market-დან დავაყენებთ, მაშინ პარამეტრებში უნდა დავუშვათ ინსტალაცია სხვა წყაროებიდან - უსაფრთხოება->უცნობი წყაროები (აპლიკაციების დაყენების დაშვება სხვა წყაროებიდან)
წინა განყოფილებაში აღწერილი keytool უტილიტა ქმნის ციფრულ სერთიფიკატს, რომელიც jarsigner-ის ერთ-ერთი ვარიანტია. სხვა ვარიანტი არის Android პაკეტი, რომელიც ხელმოწერას საჭიროებს. Android პაკეტის შესაქმნელად, თქვენ უნდა გამოიყენოთ Export Unsigned Application Package უტილიტა Eclipse ADT მოდულიდან. ამ პროგრამის გამოსაძახებლად, თქვენ უნდა დააწკაპუნოთ მაუსის მარჯვენა ღილაკით Android პროექტზე Eclipse-ში, აირჩიეთ Android Tools კონტექსტური მენიუდან და შემდეგ აირჩიეთ Export Unsigned Application Package ვარიანტი. გაშვებისას ეს პროგრამა წარმოქმნის .apk ფაილს, რომელიც არ არის ხელმოწერილი გამართვის სერთიფიკატით.
იმისათვის, რომ ეს ყველაფერი გამოსცადოთ, გაუშვით Export Unsigned Application Package უტილიტა თქვენს Android-ის ერთ-ერთ პროექტზე და შეინახეთ გენერირებული .apk ფაილი სადმე. ამ მაგალითში ჩვენ გამოვიყენებთ ადრე შექმნილ keystore საქაღალდეს და გამოვიმუშავებთ .apk ფაილს სახელად C:\android\release\myappraw.apk.
ახლა ჩვენ გვაქვს .apk ფაილი და keystore ელემენტი და შეგვიძლია jarsigner ინსტრუმენტი გავუშვათ .apk ფაილზე ხელმოწერისთვის (იხ. 14.2). ამ შემთხვევაში, სრული ბილიკები უნდა იყოს მითითებული keystore ფაილისთვის და .apk ფაილისთვის.
.apk ფაილზე ხელმოწერისთვის jarsigner-ს გადაეცემა keystore მდებარეობა, keystore პაროლი, პირადი გასაღების პაროლი, გზა .apk ფაილამდე და keystore ელემენტის მეტსახელი. შემდეგ jarsigner ხელს აწერს .apk ფაილს ციფრული სერტიფიკატით keystore ელემენტიდან. jarsigner უტილიტის გასაშვებად, თქვენ უნდა გახსნათ ინსტრუმენტის ფანჯარა (იხ. თავი 2), ან გახსნათ ბრძანების ხაზის ფანჯარა ან ტერმინალის ფანჯარა და გახსნათ bin საქაღალდე
JDK (თუ ეს საქაღალდე არ არის დაყენებული PATH გარემოს ცვლადში). უსაფრთხოების მიზეზების გამო, უმჯობესია არ გადაიტანოთ პაროლები ბრძანების არგუმენტებად, მაშინ jarsigner მოგთხოვთ შეიყვანოთ პაროლები გაშვების დროს. ნახ. 14.3 გვიჩვენებს jarsigner უტილიტის გამოძახების მაგალითს. თქვენ შეიძლება შენიშნეთ, რომ ნახ. 14.3 jarsigner ითხოვს მხოლოდ ერთ პაროლს. ეს იმიტომ ხდება, რომ კლავიატურის პაროლი არ არის მოთხოვნილი, თუ მაღაზია და კლავიატურა ემთხვევა. მკაცრად რომ ვთქვათ, jarsigner ბრძანებას e14.2-ში სჭირდება მხოლოდ -keypass პაროლის მითითება, როდესაც ის განსხვავდება -storepass პაროლისგან.
როგორც უკვე აღვნიშნეთ, Android მოითხოვს აპლიკაციის ციფრულ ხელმოწერას, რათა მავნე პროგრამისტებმა ვერ შეცვალონ თქვენი აპლიკაცია თავიანთი ვერსიით. ამისათვის Android მოითხოვს აპლიკაციის განახლებების ხელმოწერას იგივე ხელმოწერით, როგორც ორიგინალი აპი. თუ აპლიკაცია ხელმოწერილია სხვა ხელმოწერით, Android განიხილავს ამ აპებს განსხვავებულად. ამიტომ, კიდევ ერთხელ შეგახსენებთ: ფრთხილად დაამუშავეთ keystore ფაილი, რათა ის თქვენთვის ხელმისაწვდომი იყოს მოგვიანებით, როცა დაგჭირდებათ აპლიკაციის განახლების გამოშვება.
ასე რომ, თქვენ მუშაობდით მრავალი დღე (და შესაძლოა ღამე) და ახლა თქვენი პირველი ჰიბრიდული მობილური აპლიკაცია მზად არის. ის საკმაოდ სტაბილურია, კრიტიკული შეცდომების უმეტესობა დახურულია. დარჩა პატარები, მაგრამ გახსოვთ, რომ პერფექციონიზმი ბოროტებაა, თქვენ იღებთ მტკიცე გადაწყვეტილებას განაცხადის გამოქვეყნებაზე.
ამის წინაპირობაა ხელმოწერილი APK ფაილის არსებობა. როგორ მოვაწეროთ ხელი apk ფაილს, ამ სტატიიდან შეიტყობთ.
მცირე გადახრა
როდესაც ჩემი შინაური ცხოველების პროექტი გამოშვებას მიუახლოვდა, დავიწყე ინფორმაციის მოძიება, თუ როგორ გამოვაქვეყნო აპლიკაცია სწრაფად და უმტკივნეულოდ. ნაპოვნი ბევრი ინსტრუქცია მარტივი ჩანდა. მე ავირჩიე Ionic Framework-ის ავტორების ინსტრუქციები, რომლებზედაც შემუშავდა აპლიკაცია. ყველაფერი არ გამოუვიდა პირველად, არის რამდენიმე ფუნქცია. ხელმოწერის პროცესი აღწერილია ამ სტატიაში, ხაზგასმულია მნიშვნელოვანი პუნქტები.საწყისი მონაცემები
მე ვარაუდობ, რომ თქვენ გაქვთ ყველაფერი, რაც გჭირდებათ Apache Cordova-სთან ჰიბრიდული მობილური აპლიკაციების შესაქმნელად. უნდა დამონტაჟდეს:- აპაჩე კორდოვა
- ჯავის განვითარების ნაკრები
- Android SDK ინსტრუმენტები
წადი
პირველ რიგში, თქვენ უნდა შექმნათ თქვენი აპლიკაციის გამოშვების build. მანამდე კი დავრწმუნდეთ, რომ ყველა არასაჭირო დანამატი ამოღებულია. მაგალითად, ჩვენ არ გვჭირდება დანამატი, რომელიც ბეჭდავს გამართვის ინფორმაციას კონსოლში. მოვიშოროთ:$ cordova მოდული rm cordova-plugin-console
Android-ისთვის გამოშვების კონსტრუქციის შესაქმნელად გამოიყენეთ ბრძანება აშენებადროშით -- გათავისუფლება:
$ cordova build -- გამოუშვით android
ეს ბრძანება შეიქმნება ხელმოუწერელი APK ფაილი დირექტორიაში:
პლატფორმები/ანდროიდი/build/outputs/apk
მაგალითად, პლატფორმები/android/build/outputs/apk/ android-release-unsigned.apk. შემდეგ ჩვენ უნდა მოვაწეროთ ხელი ამ ფაილს და გავუშვათ პროგრამა zipalignფაილის ოპტიმიზაციისთვის და Google Play-სთვის მოსამზადებლად.
ფაილზე ხელმოწერისთვის საჭიროა სერთიფიკატი. მოდით შევქმნათ იგი უტილიტის გამოყენებით გასაღები ინსტრუმენტირომელიც შედის JDK-ში:
$ keytool -genkey -v -keystore lcf.keystore -alias lcf -keyalg RSA -keysize 2048 -validity 10000
Მნიშვნელოვანი
-ალიას პარამეტრის მნიშვნელობა უნდა დაიმახსოვროთ, მაგრამ უმჯობესია ჩაწეროთ იგი. ზემოთ მოყვანილ მაგალითში ის უდრის lcf-ს (Loyal Client Free აპლიკაციის სახელის პირველი ასოებით). დეტალებს აქ არ მოგახსენებთ, თუ დაგაინტერესებთ დაწერეთ კომენტარებში, მეტს გეტყვით.ალიასი გამოიყენება ყოველ ჯერზე ხელმოწერისას * აპლიკაციები. დამახსოვრების გასაადვილებლად გამოიყენეთ keystore ფაილის სახელი, როგორც მეტსახელი, მაგალითად:
-keystore hello-world.keystore -სხვა სახელი hello-world -keystore weather-app.keystore -სხვა სახელი weather-app -keystore todo.keystore -სხვა სახელი todo
* თქვენ უნდა მოაწეროთ აპლიკაცია განახლებების ყოველი გამოშვებით
კომუნალური გასაღები ინსტრუმენტისვამს კითხვების სერიას. სულ 8 იქნება, წინასწარ რომ გქონდეთ წარმოდგენა კითხვებზე და სავარაუდო პასუხებზე, ყველა ქვემოთ მოცემულია სპოილერის ქვეშ.
საკვანძო ინსტრუმენტების კითხვები და პასუხების ნიმუში
1. შეიყვანეთ გასაღების მაღაზიის პაროლი:
აქ თქვენ უნდა შეიყვანოთ ფაილის პაროლი (მინიმუმ 6 სიმბოლო). შეყვანილი პაროლი უნდა ჩაიწეროს უსაფრთხო ადგილას, ის საჭიროა ყოველ ჯერზე განაცხადის ხელმოწერისას.
2. ხელახლა შეიყვანეთ ახალი პაროლი:
პაროლის ხელახლა შეყვანა.
3. რა არის შენი სახელი და გვარი?
: ივან პეტროვი
შენი სახელი და გვარი. მნიშვნელობა კვადრატულ ფრჩხილებში არის ნაგულისხმევი მნიშვნელობა.
4. რა ჰქვია თქვენს ორგანიზაციულ ერთეულს?
: IT
თქვენი კომპანიის განყოფილების სახელი. თქვენ შეგიძლიათ დატოვოთ იგი ცარიელი, მე ვაკონკრეტებ IT.
5. რა ჰქვია თქვენს ორგანიზაციას?
: 2 დეველოპერები
თქვენი ორგანიზაციის სახელი. მიუთითეთ ასეთის არსებობის შემთხვევაში.
6. რა ჰქვია თქვენს ქალაქს ან ადგილს?
: მოსკოვი
Ქალაქის სახელი
7. რა ჰქვია თქვენს შტატს ან პროვინციას?
: MO
რეგიონის სახელი
8. რა არის ამ ერთეულის ორასოიანი ქვეყნის კოდი?
: EN
ქვეყნის კოდექსი. მე მივუთითებ RU.
: წ
დაადასტურეთ ყველაფერი სწორია ან დააჭირეთ Enter ხელახლა შესასვლელად.
დასასრულს გამოჩნდება შეტყობინება გასაღების წარმატებული გენერირების შესახებ. თქვენ მოგეთხოვებათ დააყენოთ პაროლი პირადი გასაღებისთვის (თუ გსურთ დატოვოთ იგივე, რაც სერთიფიკატისთვის, დააჭირეთ Enter):
2 048 ბიტიანი RSA გასაღების წყვილის და ხელმოწერილი სერტიფიკატის გენერირება (SHA256withRSA) 10 000 დღის მოქმედებით: CN=Ivan Petrov, OU=IT, O=2developers, L=Moscow, ST=MO, C=RU Enter key. პაროლისთვის
ფაილი შეიქმნება მიმდინარე დირექტორიაში lcf.keystore.
Მნიშვნელოვანი
შექმნილი ფაილი უნდა იყოს შენახული უსაფრთხო ადგილას. თუ იყენებთ პირად საცავს, მაშინ ფაილის ჩადენა შესაძლებელია აპლიკაციის წყაროს კოდებთან ერთად. ზოგადად, სერთიფიკატები საუკეთესოდ ინახება ცალკე. თუ დაკარგავთ სერთიფიკატს, ვერ შეძლებთ აპის განახლებების გამოშვებას.
დარჩენილია ორი ნაბიჯი და თქვენ გექნებათ APK ფაილი მზად განაწილებისთვის. ჩვენ პირდაპირ ვაგრძელებთ ხელმოწერას.
თქვენი apk ფაილის ხელმოწერისთვის გამოიყენეთ კომუნალური პროგრამა ჯარსინერი, რომელიც ასევე შედის JDK-ში.
$ jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore lcf.keystore android-release-unsigned.apk lcf
პარამეტრის შემდეგ მითითებულია სერტიფიკატის სახელი - გასაღებების მაღაზია, მეტსახელი - ფაილის სახელის შემდეგ.
და ბოლოს, apk ფაილის ოპტიმიზაციისთვის, ჩვენ გამოვიყენებთ კომუნალურ პროგრამას zipalign:
$ zipalign -v 4 android-release-unsigned.apk LoyalClientFree.apk
ბოლო პარამეტრი არის ფაილის სახელი, რომელსაც ატვირთავთ Google Play-ში.
Მნიშვნელოვანი.
კომუნალური zipalignის Android SDK ინსტრუმენტების ნაწილია და შეგიძლიათ იხილოთ აქ:/path/to/Android/sdk/build-tools/VERSION/zipalign
დასკვნა
ახლა თქვენ გაქვთ apk ფაილი მზად განაწილებისთვის, რომელიც შეიძლება ატვირთოთ Google Play-ში. შეავსეთ აღწერა, განსაზღვრეთ თქვენი განაცხადის რეიტინგი და თავისუფლად დააწკაპუნეთ "გამოქვეყნება".მას შემდეგ, რაც მე თვითონ დავგუგლე კითხვა როგორ მოვაწეროთ ხელი apk ფაილს?", ვიცი, რომ არც ისე ადვილია ყველაფერში მართლაც მოქმედი და გასაგები ინსტრუქციის პოვნა. ამიტომ გადავწყვიტე თავად დავწერო მასალა, თუ როგორ სწორად მოვაწერო ხელი თქვენს პროგრამას ან თამაშს Android-ზე.
მოგეხსენებათ, რომ ციფრული ხელმოწერის გარეშე, თქვენი ქმნილება არ განთავსდება ბაზარზე და ეს უკვე სერიოზულია. Android-ის ბევრმა ახალგაზრდა დეველოპერმა შენიშნა, ასე ვთქვათ, დამწყებთათვის სრულიად ავიწყდებათ ხელი მოაწერონ აპლიკაციას და რაღაცის გაკეთებას ცდილობენ. მოგვიანებით და მაინტერესებს, რატომ არ შეუძლიათ გარკვეული მოქმედებების შესრულება თავიანთი APK ფაილით.
მაშ ასე, ნუ გავაჭიანურებთ და დაუყოვნებლივ დავიწყოთ იმით, თუ როგორ შეგიძლიათ ხელი მოაწეროთ თქვენს apk ფაილს და როგორ გამოიყენოთ იგი რეალურად სასურველი შედეგის მისაღწევად.
ეს მეთოდი ყველა ჩამოთვლილიდან ყველაზე სწორია, ამიტომ მას ამ მასალაში აღვწერთ. ჩვენ გავაკეთებთ ჩვენს გასაღებებს ჩვენი მონაცემებით და სერთიფიკატებით და გამოვიყენებთ თქვენს მიერ შექმნილ აპლიკაციაზე ხელმოწერისთვის.
სამუშაოსთვის გვჭირდება: OpenSSL და SignApk.
პირველი, მოდით გავაკეთოთ სერთიფიკატი და ხელმოწერის გასაღები. დააინსტალირე OpenSSL. ინსტალაციის დროს, ინსტალერი მოგთხოვთ დააკოპიროთ კომპონენტები Windows საქაღალდეში, აირჩიეთ Bin საქაღალდე, რომელიც იქნება ადგილი, სადაც თქვენ დააინსტალირებთ მთელ OpenSSL-ს.
ახლა გახსენით სისტემის ადმინისტრატორის სახელით (ეს ძალიან მნიშვნელოვანია!) ბრძანების ხაზი. შემდეგ, ბრძანების ხაზზე, გადადით bin საქაღალდეში, რომელიც მდებარეობს საქაღალდეში, სადაც დააინსტალირეთ OpenSSL (მაგალითად, C:\OpenSSL\bin\ან C:\Program Files\OpenSSL\bin\). თუ არ იცით, სხვა საქაღალდეში გადატანა ხდება ბრძანებით cd. ანუ სასურველ საქაღალდეში გადასასვლელად უნდა აწარმოოთ შემდეგი ბრძანება:
cd C:\OpenSSL\bin\
როგორც კი Bin საქაღალდეში მოხვდებით, შეგიძლიათ პირდაპირ გააგრძელოთ სერთიფიკატის და გასაღების შექმნა.
Ნაბიჯი 1(ჩვენ ვასრულებთ გასაღების გენერირებას 1024 ბიტიანი სიგრძით)
გაუშვით ბრძანება:
openssl genrsa -out key.pem 1024
ნაბიჯი 2(გასაღების საფუძველზე, ჩვენ ვქმნით სერთიფიკატის მოთხოვნას)
გაუშვით ბრძანება:
openssl req -new -key key.pem -out request.pem
ამ ეტაპზე მოგიწევთ თქვენი მონაცემების შეყვანა, რაც დაგიდასტურებთ სერთიფიკატში.
ნაბიჯი 3 (შექმენით პირადი გასაღები სერტიფიკატიდან)
გაუშვით ბრძანება:
openssl x509 -req -days 9999 -in request.pem -signkey key.pem -out certificate.pem
ნაბიჯი 4(შეასრულეთ საჯარო გასაღების გენერაცია)
გაუშვით ბრძანება:
openssl pkcs8 -topk8 -outform DER -in key.pem -inform PEM -out key.pk8 -nocrypt
ამ ეტაპზე დასრულებულია ფაილების შექმნა, რომლებიც გვჭირდება თქვენი თამაშებისა და აპლიკაციების ხელმოწერისთვის. გენერირებული გასაღებისა და სერთიფიკატის გამოყენებით, შეგიძლიათ ხელი მოაწეროთ იმდენ თამაშსა და აპლიკაციას Android-ზე, რამდენიც გსურთ.
ახლა კი რეალურად, დავიწყოთ განაცხადზე ხელმოწერა. გახსენით არქივი SingApk-დან, გადმოწერილი ზემოთ მოცემული ბმულიდან. გადადით Bin საქაღალდიდან, სადაც შევქმენით სერთიფიკატი და გასაღები 2 ფაილი: მოწმობა.პემდა გასაღები.pk8საქაღალდეში, სადაც ამოშალეთ SingApk. Windows-მა უნდა აჩვენოს ფაილის ჩანაცვლების დიალოგი - ჩანაცვლება.
ახლა, იმისათვის, რომ ხელი მოაწეროთ apk ფაილს უნიკალური ციფრული ხელმოწერით, რომელიც თქვენ თვითონ შექმენით, უბრალოდ გადაიტანეთ თქვენი apk ფაილი sign_APK.bat. იმისათვის, რომ არ გადაიტანოთ ფაილი ერთი ფანჯრიდან მეორეში (ეს არ არის მოსახერხებელი), გადაიტანეთ თქვენი apk ფაილი საქაღალდეში SingApk-ით. შესრულების შემდეგ, ფაილი გამოჩნდება საქაღალდეში SingApk-ით apk_signed.apk, რომელიც იქნება თქვენი ხელმოწერილი აპლიკაცია ან თამაში.