Unlimited Plugins, WordPress themes, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Code
  2. iOS

Rapid, Interactive Prototyping Dengan Xcode Playgrounds

by
Difficulty:IntermediateLength:LongLanguages:

Indonesian (Bahasa Indonesia) translation by Ilham Saputra (you can also view the original English article)

Final product image
What You'll Be Creating

Pengenalan

Sejak diperkenalkan di Xcode 6 bersama Swift, hingga iterasi mereka saat ini di Xcode 7.3.1, taman bermain telah berjalan jauh. Dengan fitur-fitur baru dan stabilitas yang lebih baik, mereka berevolusi menjadi alat yang layak untuk pembuatan prototipe cepat atau dengan cepat meretas bukti konsep.

Sebagai pengembang, kadang-kadang Anda memiliki kilasan inspirasi dalam bentuk ide yang menarik untuk suatu aplikasi dan Anda ingin dengan cepat membuat kode prototipe yang mewakili esensi ide Anda. Atau Anda hanya ingin memverifikasi pemahaman Anda tentang bagaimana beberapa kode UIKit akan berperilaku. Jika Anda seperti saya, Anda lebih baik menghindari kerumitan dan gangguan mental dalam membuat proyek Xcode dan harus berurusan dengan berbagai faktor, seperti jenis dan resolusi perangkat, dan membangun pengaturan. Keputusan-keputusan ini dapat ditunda sampai setelah Anda memutuskan bahwa ide inti itu layak untuk dicapai.

Dalam tutorial ini, kami membuat gim memori berbasis kartu yang semuanya ada dalam batas-batas taman bermain. Ini adalah permainan yang umum dan terkenal, jadi tidak ada penghargaan untuk orisinalitas di sana. Permainan ini terdiri dari delapan pasang kartu identik (jadi total 16 kartu) ditempatkan menghadap ke bawah dalam kotak 4x4.

Pemain perlu membalik dua kartu yang wajahnya sebentar terungkap dan kemudian dengan cepat kembali. Tujuan permainan adalah agar pemain mencoba dan mengingat posisi kartu dan menemukan pasangan yang identik, yang kemudian dikeluarkan dari permainan. Permainan berakhir saat grid dihapus.

Gim ini berbasis sentuhan dan menggabungkan animasi tampilan sederhana. Anda belajar bagaimana Anda dapat memodifikasi aplikasi Anda dan melihat hasil perubahan Anda secara langsung.

1. Memulai

Jalankan Xcode dan pilih New > Playground ... dari menu File Xcode. Beri nama taman bermain, seperti MemoryGameXCPTut, atur Platform ke iOS, dan simpan taman bermain. Saya menggunakan Xcode 7.3.1 untuk tutorial ini.

Create A New Playground

Menemukan Jalan Anda di Sekitar Taman Bermain

Mari kita menghabiskan waktu membiasakan diri dengan antarmuka bermain. Jangan ragu membaca bagian ini jika Anda sudah terbiasa dengan taman bermain.

Taman bermain dapat memiliki beberapa halaman, masing-masing terkait dengan tampilan langsungnya sendiri dan folder sendiri sources/resources. Kami tidak akan menggunakan banyak halaman dalam tutorial ini. Playgrounds mendukung format markup yang memungkinkan Anda untuk menambahkan teks kaya ke taman bermain dan menghubungkan antara halaman taman bermain.

Hal pertama yang Anda lihat setelah membuat taman bermain adalah editor sumber taman bermain. Di sinilah Anda menulis kode, yang memiliki efek langsung pada tampilan langsung. Salah satu cara untuk mengganti (dis)appearance dari Project Navigator adalah dengan menggunakan pintasan Command-0. Di Project Navigator, Anda dapat melihat dua folder, Sources dan Resources.

Sources

Di folder Sources, Anda dapat menambahkan kode tambahan dalam satu atau lebih file Swift, seperti kelas khusus, pengontrol tampilan, dan tampilan. Meskipun sebagian besar kode yang mendefinisikan logika prototipe Anda masuk ke sana, itu adalah tambahan dalam arti bahwa itu terselip di latar belakang ketika Anda melihat aplikasi Anda hidup.

Keuntungan menempatkan kode tambahan di folder Sources adalah bahwa kode ini dikompilasi secara otomatis setiap kali Anda memodifikasi dan menyimpan file. Dengan cara ini, Anda mendapatkan umpan balik yang lebih cepat dalam tampilan langsung dari perubahan yang dilakukan di taman bermain. Kembali di taman bermain, Anda dapat mengakses properti dan metode public yang Anda paparkan dalam kode bantu yang memengaruhi cara aplikasi Anda.

Resources

Anda dapat menambahkan sumber daya eksternal, seperti gambar, di folder Resources.

Dalam tutorial ini, Anda sering harus beralih antara file Swift yang kami buat di folder Sources dan file playground (secara teknis juga file Swift, kecuali Anda tidak akan menyebutnya dengan nama file-nya). Kami juga menggunakan Assistant Editor dalam tutorial, setelah itu menampilkan Timeline, untuk melihat hasil langsung berdampingan dengan kode taman bermain. Setiap perubahan yang Anda buat di Taman Bermain tercermin langsung (well, dalam beberapa detik) dalam output hidup. Anda juga dapat berinteraksi sentuh dengan live view dan elemen antarmuka pengguna. Untuk memastikan Anda dapat melakukan semua ini, mengambil sekilas pada gambar di bawah.

Sources and Resources Folders

Sesuai dengan nomor hijau saya telah menambahkan ke angka:

  1. Tombol ini menyembunyikan Assistant Editor sehingga hanya editor utama yang terlihat.
  2. Tombol ini mengungkapkan Assistant Editor. Assistant Editor terlihat di kanan editor utama. Editor ini dapat membantu dengan menunjukkan kepada kami file yang relevan, seperti rekanan file di editor utama.
  3. Dari kiri ke kanan, kedua tombol ini masing-masing digunakan untuk mengganti tampilan Project Navigator dan konsol debug. Di konsol, kita dapat memeriksa hasil cetak laporan antara lain.
  4. Jump bar di bagian atas editor utama juga dapat digunakan untuk menavigasi ke file tertentu. Mengklik nama proyek dua kali membawa Anda kembali ke Taman Bermain. Selain itu, Anda juga dapat menggunakan Project Navigator.

Terkadang, saat melihat taman bermain, Anda perlu memastikan bahwa Assistant Editor menampilkan Timeline alih-alih beberapa file lain. Gambar di bawah ini menunjukkan cara melakukannya. Di Assistant Editor, pilih Timeline, lawan main, bukan Manual, yang memungkinkan Anda menampilkan file apa pun di Assistant Editor.

Accessing the Timeline

Saat Anda mengedit file sumber dari folder Sources, sebagai lawannya, Assistant Editor menunjukkan antarmuka kode Anda, yaitu deklarasi dan prototipe fungsi tanpa implementasinya. Saya lebih suka menyembunyikan Assistant Editor ketika saya mengerjakan file di folder Sources dan hanya mengekspos Assistant Editor di taman bermain untuk melihat tampilan langsung.

Untuk mengakses kemampuan khusus bermain, Anda perlu untuk mengimpor modul XCPlayground.

Anda mengatur properti liveView dari currentPage objek XCPlaygroundPage ke objek yang sesuai dengan protokol XCPlaygroundLiveViewable. Ini bisa menjadi kelas kustom atau itu bisa menjadi contoh UIView atau UIViewController.

Menambahkan file ke Folder Sources/Resources

Saya telah menambahkan beberapa gambar yang dapat kita kerjakan dalam tutorial ini. Unduh gambar, ekstrak arsip, dan tambahkan gambar di folder Images ke folder Resources taman bermain di Project Navigator.

Pastikan untuk menarik hanya gambar sehingga setiap file gambar berada di folder Resources, bukan di Resources/Images.

Menghapus kode di playground. Klik kanan folder Sources dan pilih New File dari menu. Atur nama file ke Game.swift.

Importing Images and Creating a New Source File

2. Menulis Kelas Penolong & Metode

Tambahkan kode berikut ke Game.swift. Pastikan Anda menyimpan file setelah setiap penambahan kode.

Saya telah menambahkan beberapa komentar bernomor untuk menjelaskan beberapa bagian implementasi:

  1. Selain UIKit dan XCPlayground, kita juga mengimpor GamePlayKit. Kerangka kerja ini mencakup metode nyaman yang akan membantu kita menerapkan metode untuk secara acak mengocok array.
  2. Ekstensi ini pada UIImage memungkinkan kita, dengan bantuan UIKit metode, untuk membuat gambar dengan warna padat dari berbagai ukuran yang kita inginkan. Kita akan menggunakan ini untuk mengatur gambar latar belakang awal dari kartu remi.
  3. Konstanta cardHeight dan cardWidth mewakili ukuran gambar kartu yang berbasis di mana kita akan menghitung ukuran lainnya.
  4. Kelas Card, yang diturunkan dari UIImageView, mewakili kartu. Meskipun kita mengatur beberapa properti di kelas Card, tujuan utama untuk menciptakan kelas ini adalah untuk membantu kami mengidentifikasi dan iterate atas subviews yang sesuai untuk bermain kartu dalam permainan. Kartu juga memiliki sifat x dan y untuk mengingat posisi mereka dalam grid.

3. Lihat Controller

Tambahkan kode berikut ke Game.swift, segera setelah kode sebelumnya:

  1. Dua properti, padding dan backImage, dinyatakan public sehingga kita dapat mengaksesnya di taman bermain nanti. Mereka mewakili ruang kosong yang mengelilingi kartu di grid dan gambar ditampilkan pada bagian belakang kartu masing-masing masing-masing. Perhatikan bahwa kedua properti telah diberi nilai awal, mewakili padding 20 dan warna merah solid untuk kartu bebas-wajah sisi gambar. Anda dapat mengabaikan kode berkomentar-out untuk saat ini.
  2. Kami menghitung masukkan lebar dan tinggi dari pandangan dengan menggunakan properti dihitung. Untuk memahami perhitungan viewWidth, ingatlah bahwa ada empat kartu di setiap baris dan kita juga perlu mempertimbangkan pengisian setiap kartu. Ide yang sama berlaku untuk perhitungan viewHeight.
  3. Kode (1...8).flatMap{[$0, $0]} adalah cara ringkas untuk menghasilkan array [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8]. Jika Anda tidak terbiasa dengan pemrograman fungsional, Anda juga bisa menulis for-loop untuk menghasilkan array. Kami menggunakan metode dari kerangka GamePlayKit, shuffle angka-angka dalam array. Nomor sesuai dengan delapan pasang kartu. Setiap angka menunjukkan gambar kartu nama yang sama (misalnya, nilai 1 di shuffledArray sesuai dengan 1.png).
  4. Kami menulis metode yang memetakan lokasi kartu pada kisi 4x4 ke lokasinya di array shuffledNumbers panjang 16. Faktor 4 dalam perhitungan aritmatika mencerminkan fakta bahwa kita memiliki empat kartu per baris.
  5. Kami juga memiliki metode yang mengetahui posisi kartu (properti center) di grid berdasarkan dimensi dan bantalan kartu.
  6. Metode setupGrid() disebut selama inisialisasi Lihat controller. Itu menjabarkan kotak Card 4x4. Itu juga menetapkan identitas masing-masing kartu berdasarkan array ShuffledNumbers dan menyimpannya di properti tag yang diwarisi dari kelas dasar kartu, UIView. Dalam permainan logika, kita membandingkan nilai tag untuk mengetahui apakah dua kartu cocok atau tidak. Skema ini agak dasar pemodelan menyajikan cukup baik untuk kebutuhan kita saat ini.
  7. Potongan kode ini saat ini tidak terpakai akan membantu kita reposisi kartu dalam kasus padding perubahan. Ingat bahwa kita mendeklarasikan properti padding sebagai milik umum sehingga kita dapat mengaksesnya di Taman Bermain.
  8. Kode dalam viewDidAppear(_:) berjalan segera setelah tampilan controller pandangan menjadi terlihat. Kami iterate melalui pandangan yang subviews dan jika subview adalah instance kelas Card, (cek melalui as? failable downcasting operator) tubuh pernyataan-if mendefinisikan transisi untuk melakukan. Ini adalah di mana kita akan mengubah gambar yang ditampilkan pada kartu, dari gambar kartun mendefinisikan wajah setiap kartu backImage (umum) dari semua kartu. Transisi ini disertai dengan animasi flip kiri-ke-kanan yang memberikan tampilan kartu fisik yang diserahkan. Jika Anda tidak akrab dengan cara kerja UIView animasi, ini mungkin tampak sedikit aneh. Meskipun kita menambahkan animasi masing-masing kartu secara berurutan dalam satu lingkaran, animasi batched pembelian satu animasi dan dijalankan secara bersamaan, yaitu kartu flip bersama-sama.

Mengunjungi Taman Bermain dan mengganti teks dalam editor dengan berikut:

Pastikan timeline terlihat. Tampilan Lihat controller harus musim semi untuk hidup dan menunjukkan kepada kita grid 4 x 4 kartu dengan hewan kartun lucu yang menjungkir untuk menunjukkan bagian belakang kartu. Tepat sekarang, kita tidak bisa berbuat banyak dengan pandangan ini karena kita belum diprogram setiap interaksi ke dalamnya belum. Tapi itu pasti sebuah awal.

First Output

4. Memodifikasi Variabel di Playground

Sekarang mari kita ubah wajah belakang kartu dari merah menjadi gambar, khususnya b.png di folder Resources. Tambahkan baris berikut ke bagian bawah taman bermain.

Setelah satu atau dua detik, Anda akan melihat bahwa sisi belakang kartu telah berubah dari dataran merah untuk tangan kartun.

Changing the Back Image of the Cards From the Playground

Sekarang mari kita coba untuk mengubah properti padding, yang kami berikan nilai default 20 di Game.swift. Ruang antara kartu harus meningkatkan sebagai akibatnya. Tambahkan baris berikut ke bagian bawah tempat bermain:

Menunggu untuk live view untuk me-refresh dan melihat bahwa... tidak ada yang berubah.

5. Jalan memutar singkat

Untuk memahami apa yang terjadi, Anda harus diingat bahwa entitas, misalnya tampilan controller dan pandangan mereka terkait, memiliki siklus kehidupan yang kompleks. Kita akan fokus pada yang kedua, yaitu pemandangan. Membuat dan memperbarui tampilan controller lihat adalah proses multistage. Pada titik tertentu dalam siklus hidup pandangan, pemberitahuan yang dikeluarkan untuk UIViewController, menginformasikan itu apa yang terjadi. Lebih penting lagi, pemrogram dapat menghubungkan ke pemberitahuan ini dengan memasukkan kode untuk mengarahkan dan menyesuaikan proses ini.

Metode loadView() dan viewDidAppear(_ :) adalah dua metode yang kami gunakan untuk menghubungkan ke siklus hidup tampilan. Topik ini agak terlibat dan luar cakupan diskusi ini, tetapi apa yang penting bagi kita adalah bahwa kode di Taman Bermain, setelah penugasan controller lihat sebagai tempat bermain liveView, dijalankan beberapa waktu antara panggilan untuk viewWillAppear(_:) dan panggilan untuk viewDidAppear(_:). Anda dapat memverifikasi ini dengan memodifikasi beberapa properti di taman bermain dan menambahkan pernyataan cetak ke dua metode ini untuk menampilkan nilai properti ini.

Masalah dengan nilai padding yang tidak memiliki efek visual yang diharapkan adalah, pada saat itu, tampilan dan subview-nya telah ditata. Perlu diingat bahwa, setiap kali Anda membuat perubahan ke kode, tempat bermain adalah jalankan kembali dari awal. Dalam pengertian itu, masalah ini tidak khusus untuk bermain. Bahkan jika Anda mengembangkan kode untuk dijalankan pada simulator atau pada perangkat fisik, sering kali Anda perlu menulis kode tambahan untuk memastikan bahwa perubahan nilai properti memiliki efek yang diinginkan pada tampilan atau konten tampilan.

Anda mungkin bertanya mengapa kita mampu untuk mengubah nilai properti backImage dan melihat hasil tanpa melakukan sesuatu yang istimewa. Mengamati bahwa properti backImage benar-benar digunakan untuk pertama kalinya dalam viewDidAppear(_:), yang pada saat itu telah sudah mengambil nilai baru.

6. Mengamati Properti dan Mengambil Tindakan

Cara kami untuk menghadapi situasi ini adalah dengan memantau perubahan nilai padding dan mengubah ukuran/memposisikan ulang tampilan dan subview. Untungnya, ini mudah dilakukan dengan fitur pengamatan properti Swift yang praktis. Mulai dengan menghapus komentar kode untuk metode resetGrid() di Game.swift:

Metode ini menghitung ulang posisi frame tampilan dan bahwa setiap objek Card berdasarkan nilai-nilai baru viewWidth dan viewHeight. Ingatlah bahwa properti ini dihitung berdasarkan nilai padding, yang baru saja dimodifikasi.

Juga, modifikasi kode untuk padding untuk menggunakan pengamat didSet yang tubuhnya, seperti namanya, dieksekusi setiap kali kita mengatur nilai padding:

Metode resetGrid() memulai dan tampilan di-refresh untuk mencerminkan spasi baru. Anda dapat memverifikasi ini di taman bermain.

Padding Successfully Updated

Tampaknya kami mampu memperbaiki hal cukup mudah. Pada kenyataannya, ketika saya pertama kali memutuskan saya ingin untuk dapat berinteraksi dengan properti padding, aku harus kembali dan melakukan perubahan kode dalam Game.swift. Sebagai contoh, saya harus mengabstraksi perhitungan pusat Card dalam fungsi yang terpisah (centerOfCardAt(_:_:)) untuk secara bersih dan mandiri (re)menghitung posisi kartu setiap kali mereka perlu ditata.

Membuat properti yang dihitung untuk viewWidth dan viewHeight juga membantu. Meskipun jenis penulisan ulang ini adalah sesuatu yang harus Anda persiapkan sebagai trade-off dari tidak melakukan banyak desain di muka, itu dapat dikurangi dengan beberapa pemikiran dan pengalaman.

7. Logika Game & Interaksi Sentuh

Sekarang saatnya untuk mengimplementasikan logika permainan dan memungkinkan diri kita untuk berinteraksi dengannya melalui sentuhan. Mulailah dengan menghapus komentar properti firstCard di kelas GameController:

Ingatlah bahwa logika permainan melibatkan pengungkapan dua kartu, satu demi satu. Variabel ini melacak apakah flip kartu dilakukan oleh pemain adalah yang pertama dari keduanya atau tidak.

Tambahkan metode berikut ke bagian bawah kelas GameController, sebelum kurung kurawal berakhir:


Itulah metode yang panjang. Itu adalah karena itu bungkus semua sentuhan diperlukan penanganan, permainan logika serta terkait animasi dalam satu metode. Mari kita lihat bagaimana metode ini tidak bekerja:

  • Pertama, ada cek untuk memastikan bahwa pengguna benar-benar menyentuh instance Card. Ini adalah as? membangun bahwa kita digunakan sebelumnya.
  • Jika pengguna menyentuh instance Card, kami balikkan menggunakan animasi yang mirip dengan yang kami terapkan sebelumnya. Aspek hanya baru adalah bahwa kita menggunakan penyelesaian handler, yang melakukan setelah animasi selesai, sementara menonaktifkan sentuhan interaksi untuk kartu dengan mengatur properti kartu userInteractionEnabled. Hal ini mencegah pemain dari membolak-balik kartu yang sama. Perhatikan _in membangun digunakan beberapa kali dalam metode ini. Ini adalah hanya untuk mengatakan bahwa kita ingin mengabaikan parameter Bool yang mengambil handler penyelesaian.
  • Kami mengeksekusi kode berdasarkan pada apakah firstCard telah diberikan nilai nihil menggunakan pengikatan opsional, Swift's familiar konstruksi if let.
  • Jika firstCard tidak nol, maka ini adalah kartu kedua dari urutan yang pemain putar. Kita sekarang perlu membandingkan wajah kartu ini dengan yang sebelumnya (dengan membandingkan nilai tag) untuk melihat apakah kami mendapat kecocokan atau tidak. Jika kami melakukannya, kami menghidupkan kartu yang memudar (dengan mengatur alpha ke 0). Kami juga mengeluarkan kartu-kartu ini dari pandangan. Jika tag tidak sama, artinya kartu tidak cocok, kami balik saja menghadap ke bawah dan setel userInteractionEnabled menjadi true sehingga pengguna dapat memilihnya kembali.
  • Berdasarkan nilai firstCard saat ini, kami menetapkannya menjadi nil atau ke kartu ini. Inilah cara kami mengubah perilaku kode di antara dua sentuhan berurutan.

Terakhir, batalkan komentar dua pernyataan berikut di penginisialisasi GameController yang menambahkan pengenal isyarat tap pada tampilan. Saat pengenal isyarat ketuk mendeteksi ketukan, metode handleTap() dipanggil:

Kembali ke timeline taman bermain dan mainkan permainan memori. Jangan ragu untuk mengurangi padding besar yang kami berikan sedikit lebih awal.

Kode di handleTap(_ :) cukup banyak versi tanpa hiasan dari apa yang saya tulis pertama kali. Orang mungkin mengajukan keberatan bahwa, sebagai metode tunggal, itu terlalu banyak. Atau bahwa kode tidak cukup berorientasi objek dan bahwa logika membalik kartu dan animasi harus disarikan dengan rapi ke dalam metode kelas Card. Meskipun keberatan ini tidak tidak valid per se, ingat bahwa prototyping cepat adalah fokus dari tutorial ini dan karena kami tidak melihat adanya kebutuhan untuk berinteraksi dengan bagian kode ini di taman bermain, kami bisa menjadi sedikit lebih "hack -ish".

Setelah kami memiliki sesuatu yang berfungsi dan kami memutuskan untuk mengejar ide lebih lanjut, kami tentu harus mempertimbangkan kode refactoring. Dengan kata lain, pertama membuatnya bekerja, kemudian membuatnya fast/elegant/pretty/...

8. Sentuh Penanganan Di Tempat Bermain

Sementara bagian utama dari tutorial sekarang berakhir, sebagai samping yang menarik, saya ingin menunjukkan kepada Anda bagaimana kita bisa menulis kode penanganan sentuhan langsung di taman bermain. Pertama-tama kita akan menambahkan metode ke kelas GameController yang memungkinkan kita untuk mengintip wajah kartu. Tambahkan kode berikut ke kelas GameController, segera setelah metode handleTap(_ :):

Misalkan kita ingin kemampuan untuk mengaktifkan atau menonaktifkan fitur "intip cepat" dari dalam taman bermain. Salah satu cara untuk melakukannya adalah dengan membuat properti Bool publik di kelas GameController yang bisa kita atur di taman bermain. Dan tentu saja, kita harus menulis penangan gerakan di kelas GameController, diaktifkan oleh gerakan yang berbeda, yang akan memanggil quickPeek().

Cara lain adalah dengan menulis kode penanganan gerakan langsung di taman bermain. Keuntungan melakukannya dengan cara ini adalah kita dapat memasukkan beberapa kode khusus selain memanggil quickPeek(). Inilah yang akan kita lakukan selanjutnya. Tambahkan kode berikut ke bagian bawah taman bermain:

Untuk mengaktifkan fitur mengintip cepat, kita akan menggunakan gerakan tekan lama, yaitu, pemain memegang jari mereka di layar untuk jangka waktu tertentu. Kami menggunakan dua detik sebagai ambang.

Untuk menangani gerakan, kami membuat kelas, LPGR (long press gesture recognizer abbreviated), dengan properti variabel static, counter, untuk melacak berapa kali kami mengintip, dan metode static longPressed(_ :) untuk menangani gerakan .

Dengan menggunakan kualifikasi static, kita dapat menghindari keharusan membuat instance LPGR karena entitas yang dinyatakan statis terkait dengan tipe (kelas) LPGR daripada dengan instance tertentu.

Selain itu, tidak ada keuntungan khusus untuk pendekatan ini. Untuk alasan yang rumit, kita perlu menandai metode @objc agar kompiler tetap senang. Perhatikan penggunaan LPGR.self untuk merujuk pada jenis objek. Perhatikan juga bahwa di penangan isyarat, kami memeriksa apakah state isyarat .Began. Ini karena gerakan tekan lama terus menerus, yaitu, pawang akan melakukan berulang kali selama pengguna tetap menggunakan jari mereka di layar. Karena kami hanya ingin kode dijalankan sekali per jari tekan, kami melakukannya ketika gerakan pertama kali dikenali.

Penghitung tambahan adalah kode khusus yang kami perkenalkan, yang tidak bergantung pada fungsionalitas yang disediakan oleh kelas GameController. Anda dapat melihat output dari fungsi print(_ :) (setelah mengintip beberapa kali) di konsol di bagian bawah.

Gesture Recognizer With External Behavior

Kesimpulan

Semoga tutorial ini menunjukkan contoh menarik dari prototyping interaktif cepat di taman bermain Xcode Terlepas dari alasan menggunakan taman bermain yang saya sebutkan sebelumnya, Anda bisa memikirkan skenario lain di mana mereka bisa berguna. Sebagai contoh:

  • mendemonstrasikan fungsionalitas prototipe kepada klien dan membiarkan mereka memilih opsi dan membuat penyesuaian dengan umpan balik langsung dan tanpa harus menggali rincian kode yang rumit.
  • mengembangkan simulasi, seperti untuk fisika, di mana siswa dapat bermain dengan beberapa nilai parameter dan mengamati bagaimana simulasi dipengaruhi. Bahkan, Apple telah merilis taman bermain yang mengesankan yang menampilkan interaktivitas dan penggabungan fisika mereka melalui API UIDynamics. Saya mendorong Anda untuk memeriksanya.

Saat menggunakan taman bermain untuk tujuan demonstration/teaching seperti ini, Anda mungkin ingin memanfaatkan kemampuan markup taman bermain secara bebas untuk teks dan navigasi yang kaya.

Tim Xcode tampaknya berkomitmen untuk meningkatkan taman bermain ketika versi baru IDE diluncurkan. Berita utama adalah bahwa Xcode 8, saat ini dalam versi beta, akan menampilkan taman bermain untuk iPad. Tapi, tentu saja, taman bermain tidak dimaksudkan untuk menggantikan Xcode IDE yang lengkap dan kebutuhan untuk menguji pada perangkat yang sebenarnya ketika mengembangkan aplikasi fungsional lengkap. Pada akhirnya, mereka hanyalah alat untuk digunakan ketika itu masuk akal, tetapi sangat berguna.

Advertisement
Advertisement
Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.