Halo, Panduan Mulai Cepat tvOS

Panduan ini menjelaskan cara membuat aplikasi Xamarin.tvOS pertama Anda dan toolchain pengembangannya. Ini juga memperkenalkan Xamarin Designer, yang mengekspos kontrol UI ke kode, dan menggambarkan cara membangun, menjalankan, dan menguji aplikasi Xamarin.tvOS.

Peringatan

Desainer iOS tidak digunakan lagi di Visual Studio 2019 versi 16.8 dan Visual Studio 2019 untuk Mac versi 8.8, dan dihapus di Visual Studio 2019 versi 16.9 dan Visual Studio untuk Mac versi 8.9. Cara yang disarankan untuk membangun antarmuka pengguna iOS adalah langsung di Mac yang menjalankan Penyusun Antarmuka Xcode. Untuk informasi selengkapnya, lihat Mendesain antarmuka pengguna dengan Xcode.

Apple telah merilis Apple TV generasi ke-5, Apple TV 4K, yang menjalankan tvOS 11.

Platform Apple TV terbuka untuk pengembang, memungkinkan mereka membuat aplikasi yang kaya dan imersif dan merilisnya melalui App Store bawaan Apple TV.

Jika Anda terbiasa dengan pengembangan Xamarin.iOS, Anda harus menemukan transisi ke tvOS cukup sederhana. Sebagian besar API dan fitur sama, namun, banyak API umum tidak tersedia (seperti WebKit). Selain itu, bekerja dengan Siri Remote menimbulkan beberapa tantangan desain yang tidak ada di perangkat iOS berbasis layar sentuh.

Panduan ini akan memberikan pengantar untuk bekerja dengan tvOS di aplikasi Xamarin. Untuk informasi selengkapnya di tvOS, silakan lihat dokumentasi Apple Bersiap untuk Apple TV 4K .

Gambaran Umum

Xamarin.tvOS memungkinkan Anda mengembangkan aplikasi Apple TV yang sepenuhnya asli di C# dan .NET menggunakan pustaka OS X dan kontrol antarmuka yang sama yang digunakan saat mengembangkan di Swift (atau Objective-C) dan Xcode.

Selain itu, karena aplikasi Xamarin.tvOS ditulis dalam aplikasi C# dan .NET, umum, kode backend dapat dibagikan dengan aplikasi Xamarin.iOS, Xamarin.Android dan Xamarin.Mac; semua saat memberikan pengalaman asli di setiap platform.

Artikel ini akan memperkenalkan Anda pada konsep utama yang diperlukan untuk membuat Aplikasi Apple TV menggunakan Xamarin.tvOS dan Visual Studio dengan memandu Anda melalui proses membangun aplikasi Hello, tvOS dasar yang menghitung berapa kali tombol telah diklik:

Kami akan membahas konsep berikut:

• Visual Studio untuk Mac – Pengantar Visual Studio untuk Mac dan cara membuat aplikasi Xamarin.tvOS dengannya.
• Anatomi Aplikasi Xamarin.tvOS – Apa yang terdiri dari aplikasi Xamarin.tvOS.
• Membuat Antarmuka Pengguna – Cara menggunakan Xamarin Designer untuk iOS untuk membuat antarmuka pengguna.
• Penyebaran dan Pengujian – Cara menjalankan dan menguji aplikasi Anda di simulator tvOS dan di perangkat keras tvOS nyata.

Memulai Aplikasi Xamarin.tvOS baru di Visual Studio untuk Mac

Seperti yang dinyatakan di atas, kita akan membuat app Apple TV yang disebut Hello-tvOS yang menambahkan satu tombol dan label ke layar utama. Ketika tombol diklik, label akan menampilkan berapa kali tombol telah diklik.

Untuk memulai, mari kita lakukan hal berikut:

1. Mulai Visual Studio untuk Mac:

   

2. Klik tautan Solusi Baru... di sudut kiri atas layar untuk membuka kotak dialog Proyek Baru.

3. Pilih Aplikasi Tampilan Tunggal Aplikasi>tvOS>dan klik tombol Berikutnya:

   

4. Masukkan Hello, tvOS untuk Nama Aplikasi, masukkan Pengidentifikasi Organisasi Anda dan klik tombol Berikutnya:

   

5. Masukkan Hello_tvOS untuk Nama Proyek dan klik tombol Buat :

   

Visual Studio untuk Mac akan membuat aplikasi Xamarin.tvOS baru dan menampilkan file default yang ditambahkan ke solusi aplikasi Anda:

Visual Studio untuk Mac menggunakan Solusi dan Proyek, dengan cara yang sama persis seperti yang dilakukan Visual Studio. Solusinya adalah kontainer yang dapat menampung satu atau beberapa proyek; proyek dapat mencakup aplikasi, pustaka pendukung, aplikasi pengujian, dll. Dalam hal ini, Visual Studio untuk Mac telah membuat solusi dan proyek aplikasi untuk Anda.

Jika mau, Anda dapat membuat satu atau beberapa proyek pustaka kode yang berisi kode bersama umum. Proyek pustaka ini dapat digunakan oleh proyek aplikasi atau dibagikan dengan proyek aplikasi Xamarin.tvOS lainnya (atau Xamarin.iOS, Xamarin.Android dan Xamarin.Mac berdasarkan jenis kode), seperti yang Anda lakukan jika Anda membangun aplikasi .NET standar.

Anatomi Aplikasi Xamarin.tvOS

Jika Anda terbiasa dengan pemrograman iOS, Anda akan melihat banyak kesamaan di sini. Bahkan, tvOS 9 adalah subset dari iOS 9, sehingga banyak konsep yang akan menyeberang di sini.

Mari kita lihat file dalam proyek:

• Main.cs – Ini berisi titik masuk utama aplikasi. Saat aplikasi diluncurkan, ini berisi kelas dan metode pertama yang dijalankan.
• AppDelegate.cs – File ini berisi kelas aplikasi utama yang bertanggung jawab untuk mendengarkan peristiwa dari sistem operasi.
• Info.plist – File ini berisi properti aplikasi seperti nama aplikasi, ikon, dll.
• ViewController.cs – Ini adalah kelas yang mewakili jendela utama dan mengontrol siklus hidupnya.
• ViewController.designer.cs – File ini berisi kode pipa yang membantu Anda berintegrasi dengan antarmuka pengguna layar utama.
• Main.storyboard – UI untuk jendela utama. File ini dapat dibuat dan dikelola oleh Xamarin Designer untuk iOS.

Di bagian berikut, kita akan melihat sekilas beberapa file ini. Kami akan menjelajahinya secara lebih rinci nanti, tetapi ada baiknya untuk memahami dasar-dasarnya sekarang.

Main.cs

File Main.cs berisi metode statis Main yang membuat instans aplikasi Xamarin.tvOS baru dan meneruskan nama kelas yang akan menangani peristiwa OS, yang dalam kasus kami adalah AppDelegate kelas:

using UIKit;

namespace Hello_tvOS
{
    public class Application
    {
        // This is the main entry point of the application.
        static void Main (string[] args)
        {
            // if you want to use a different Application Delegate class from "AppDelegate"
            // you can specify it here.
            UIApplication.Main (args, null, "AppDelegate");
        }
    }
}

AppDelegate.cs

File AppDelegate.cs berisi kelas kami AppDelegate , yang bertanggung jawab untuk membuat jendela kami dan mendengarkan peristiwa OS:

using Foundation;
using UIKit;

namespace Hello_tvOS
{
    // The UIApplicationDelegate for the application. This class is responsible for launching the
    // User Interface of the application, as well as listening (and optionally responding) to application events from iOS.
    [Register ("AppDelegate")]
    public class AppDelegate : UIApplicationDelegate
    {
        // class-level declarations

        public override UIWindow Window {
            get;
            set;
        }

        public override bool FinishedLaunching (UIApplication application, NSDictionary launchOptions)
        {
            // Override point for customization after application launch.
            // If not required for your application you can safely delete this method

            return true;
        }

        public override void OnResignActivation (UIApplication application)
        {
            // Invoked when the application is about to move from active to inactive state.
            // This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message)
            // or when the user quits the application and it begins the transition to the background state.
            // Games should use this method to pause the game.
        }

        public override void DidEnterBackground (UIApplication application)
        {
            // Use this method to release shared resources, save user data, invalidate timers and store the application state.
            // If your application supports background execution this method is called instead of WillTerminate when the user quits.
        }

        public override void WillEnterForeground (UIApplication application)
        {
            // Called as part of the transition from background to active state.
            // Here you can undo many of the changes made on entering the background.
        }

        public override void OnActivated (UIApplication application)
        {
            // Restart any tasks that were paused (or not yet started) while the application was inactive.
            // If the application was previously in the background, optionally refresh the user interface.
        }

        public override void WillTerminate (UIApplication application)
        {
            // Called when the application is about to terminate. Save data, if needed. See also DidEnterBackground.
        }
    }
}

Kode ini mungkin tidak dikenal kecuali Anda telah membangun aplikasi iOS sebelumnya, tetapi cukup mudah. Mari kita periksa baris penting.

Pertama, mari kita lihat deklarasi variabel tingkat kelas:

public override UIWindow Window {
            get;
            set;
        }

Properti Window ini menyediakan akses ke jendela utama. tvOS menggunakan apa yang dikenal sebagai pola Pengontrol Tampilan Model (MVC). Umumnya, untuk setiap jendela yang Anda buat (dan untuk banyak hal lain dalam jendela), ada pengontrol, yang bertanggung jawab atas siklus hidup jendela, seperti menunjukkannya, menambahkan tampilan baru (kontrol) ke dalamnya, dll.

Selanjutnya, kita memiliki metode .FinishedLaunching Metode ini berjalan setelah aplikasi dibuat, dan bertanggung jawab untuk benar-benar membuat jendela aplikasi dan memulai proses menampilkan tampilan di dalamnya. Karena aplikasi kami menggunakan Storyboard untuk menentukan UI-nya, tidak ada kode tambahan yang diperlukan di sini.

Ada banyak metode lain yang disediakan dalam templat seperti DidEnterBackground dan WillEnterForeground. Ini dapat dihapus dengan aman jika peristiwa aplikasi tidak digunakan di aplikasi Anda.

ViewController.cs

Kelas ViewController adalah pengontrol jendela utama kami. Itu berarti bertanggung jawab atas siklus hidup jendela utama. Kita akan memeriksa ini secara rinci nanti, untuk saat ini mari kita lihat sekilas:

using System;
using Foundation;
using UIKit;

namespace Hello_tvOS
{
    public partial class ViewController : UIViewController
    {
        public ViewController (IntPtr handle) : base (handle)
        {
        }

        public override void ViewDidLoad ()
        {
            base.ViewDidLoad ();
            // Perform any additional setup after loading the view, typically from a nib.
        }

        public override void DidReceiveMemoryWarning ()
        {
            base.DidReceiveMemoryWarning ();
            // Release any cached data, images, etc that aren't in use.
        }
    }
}

ViewController.Designer.cs

File perancang untuk kelas Jendela Utama kosong sekarang, tetapi akan secara otomatis diisi oleh Visual Studio untuk Mac saat kami membuat Antarmuka Pengguna kami dengan Perancang iOS:

using Foundation;

namespace HellotvOS
{
    [Register ("ViewController")]
    partial class ViewController
    {
        void ReleaseDesignerOutlets ()
        {
        }
    }
}

Kami biasanya tidak peduli dengan file desainer, karena hanya dikelola secara otomatis oleh Visual Studio untuk Mac dan hanya menyediakan kode pipa yang diperlukan yang memungkinkan akses ke kontrol yang kami tambahkan ke jendela atau tampilan apa pun di aplikasi kami.

Sekarang setelah kami membuat aplikasi Xamarin.tvOS dan kami memiliki pemahaman dasar tentang komponennya, mari kita lihat membuat UI.

Membuat Antarmuka Pengguna

Anda tidak perlu menggunakan Xamarin Designer untuk iOS untuk membuat Antarmuka Pengguna untuk aplikasi Xamarin.tvOS Anda, UI dapat dibuat langsung dari kode C# tetapi itu di luar cakupan artikel ini. Demi kesederhanaan, kami akan menggunakan iOS Designer untuk membuat UI kami di seluruh tutorial ini.

Untuk mulai membuat UI Anda, mari kita klik Main.storyboard dua kali file di Penjelajah Solusi untuk membukanya untuk pengeditan di iOS Designer:

Ini akan meluncurkan Perancang dan terlihat seperti berikut ini:

Untuk informasi selengkapnya tentang iOS Designer dan cara kerjanya, lihat panduan Pengenalan Xamarin Designer untuk iOS .

Kita sekarang dapat mulai menambahkan kontrol ke permukaan desain aplikasi Xamarin.tvOS kami.

Lakukan:

1. Temukan Kotak Alat, yang seharusnya berada di sebelah kanan permukaan desain:

   

   Jika Anda tidak dapat menemukannya di sini, telusuri ke Lihat > Kotak Alat Pads > untuk melihatnya.

2. Seret Label dari Kotak Alat ke permukaan desain:

   

3. Klik properti Judul di pad Properti dan ubah judul tombol menjadi Hello, tvOS dan atur Ukuran Font ke 128:

   

4. Mengubah ukuran label sehingga semua kata terlihat dan menempatkannya di tengah dekat bagian atas jendela:

   

5. Label sekarang perlu dibatasi untuk posisinya, sehingga muncul seperti yang diinginkan. terlepas dari ukuran layar. Untuk melakukan ini, klik label hingga handel berbentuk T muncul:

   

6. Untuk membatasi label secara horizontal, pilih kotak tengah dan seret ke garis putus-putus vertikal:

   

   Label harus berubah menjadi oranye.

7. Pilih handel T di bagian atas label, dan seret ke tepi atas jendela:

   

8. Selanjutnya, klik lebar lalu gagang tulang tinggi seperti yang diilustrasikan di bawah ini:

   

   Saat setiap handel tulang diklik, pilih Lebar dan Tinggi masing-masing untuk mengatur dimensi tetap.

9. Setelah selesai, Batasan Anda akan terlihat mirip dengan yang ada di tab Tata Letak di pad Properti:

   

10. Seret Tombol dari Kotak Alat dan letakkan di bawah Label.

11. Klik properti Judul di pad Properti dan ubah judul tombol menjadi Click Me:

    

12. Ulangi langkah 5 hingga 8 di atas untuk membatasi tombol di jendela tvOS. Namun, alih-alih menyeret handel T ke bagian atas jendela (seperti pada langkah #7), seret ke bagian bawah label:

    

13. Seret label lain di bawah tombol, ubah ukurannya menjadi lebar yang sama dengan label pertama dan atur Perataannya ke Tengah:

    

14. Seperti label dan tombol pertama, atur label ini ke tengah dan sematkan ke lokasi dan ukuran:

    

15. Simpan perubahan Anda ke Antarmuka Pengguna.

Saat Anda mengubah ukuran dan memindahkan kontrol, Anda seharusnya memperhatikan bahwa perancang memberi Anda petunjuk snap bermanfaat yang didasarkan pada Pedoman Antarmuka Manusia Apple TV. Panduan ini akan membantu Anda membuat aplikasi berkualitas tinggi yang akan memiliki tampilan dan nuansa yang akrab bagi pengguna Apple TV.

Jika Anda melihat di bagian Kerangka Dokumen, perhatikan bagaimana tata letak dan hierarki elemen yang membentuk Antarmuka pengguna kami ditampilkan:

Dari sini Anda dapat memilih item untuk diedit atau diseret untuk menyusun ulang elemen UI jika diperlukan. Misalnya, jika elemen UI sedang dicakup oleh elemen lain, Anda dapat menyeretnya ke bagian bawah daftar untuk menjadikannya item terbanyak di jendela.

Sekarang setelah Antarmuka Pengguna dibuat, kita perlu mengekspos item UI sehingga Xamarin.tvOS dapat mengakses dan berinteraksi dengannya dalam kode C#.

Mengakses kontrol dalam kode di belakang

Ada dua cara utama untuk mengakses kontrol yang telah Anda tambahkan di perancang iOS dari kode:

• Membuat penanganan aktivitas pada kontrol.
• Memberi nama kontrol, sehingga kita nantinya dapat mereferensikannya.

Ketika salah satu dari ini ditambahkan, kelas parsial dalam ViewController.designer.cs akan diperbarui untuk mencerminkan perubahan. Ini akan memungkinkan Anda untuk kemudian mengakses kontrol di Pengontrol Tampilan.

Membuat penanganan aktivitas

Dalam aplikasi sampel ini, ketika tombol diklik, kami ingin sesuatu terjadi, sehingga penanganan aktivitas perlu ditambahkan ke peristiwa tertentu pada tombol. Untuk menyiapkan ini, lakukan hal berikut:

1. Di Xamarin iOS Designer, pilih tombol pada View Controller.

2. Di pad Properti, pilih tab Peristiwa :

   

3. Temukan peristiwa TouchUpInside, dan berikan penanganan aktivitas bernama Clicked:

   

4. Saat Anda menekan Enter, file ViewController.cs akan terbuka, menyarankan lokasi untuk penanganan aktivitas Anda dalam kode. Gunakan tombol panah pada keyboard Anda untuk mengatur lokasi:

   

5. Ini akan membuat metode parsial seperti yang ditunjukkan di bawah ini:

   

Kami sekarang siap untuk mulai menambahkan beberapa kode untuk memungkinkan tombol berfungsi.

Penamaan kontrol

Saat tombol diklik, label harus diperbarui berdasarkan jumlah klik. Untuk melakukan ini, kita perlu mengakses label dalam kode. Ini dilakukan dengan memberinya nama. Lakukan:

1. Buka Storyboard, dan pilih Label di bagian bawah Pengontrol Tampilan.

2. Di pad Properti, pilih tab Widget :

   

3. Di bawah Nama Identitas>, tambahkan ClickedLabel:

   

Kami sekarang siap untuk mulai memperbarui label!

Bagaimana kontrol diakses

Jika Anda memilih ViewController.designer.cs di Penjelajah Solusi Anda akan dapat melihat bagaimana ClickedLabel label dan Clicked penanganan aktivitas telah dipetakan ke Outlet dan Tindakan di C#:

Anda mungkin juga melihat bahwa ViewController.designer.cs adalah kelas parsial, sehingga Visual Studio untuk Mac tidak perlu memodifikasi ViewController.cs yang akan menimpa perubahan apa pun yang telah kami buat ke kelas.

Mengekspos elemen UI dengan cara ini, memungkinkan Anda mengaksesnya di Pengontrol Tampilan.

Anda biasanya tidak perlu membuka ViewController.designer.cs diri, itu disajikan di sini hanya untuk tujuan pendidikan.

Menulis Kode

Dengan Antarmuka Pengguna kami yang dibuat dan elemen UI-nya terekspos ke kode melalui Outlet dan Tindakan, kami akhirnya siap untuk menulis kode untuk memberikan fungsionalitas program.

Dalam aplikasi kami, setiap kali tombol pertama diklik, kami akan memperbarui label kami untuk menunjukkan berapa kali tombol telah diklik. Untuk mencapai hal ini, kita perlu membuka ViewController.cs file untuk pengeditan dengan mengklik dua kali di Solution Pad:

Pertama, kita perlu membuat variabel tingkat kelas di kelas kita ViewController untuk melacak jumlah klik yang telah terjadi. Edit definisi kelas dan buat terlihat seperti berikut ini:

using System;
using Foundation;
using UIKit;

namespace Hello_tvOS
{
    public partial class ViewController : UIViewController
    {
        private int numberOfTimesClicked = 0;
        ...

Selanjutnya, di kelas yang sama (ViewController), kita perlu mengambil alih metode ViewDidLoad dan menambahkan beberapa kode untuk mengatur pesan awal untuk label kita:

public override void ViewDidLoad ()
{
    base.ViewDidLoad ();

    // Set the initial value for the label
    ClickedLabel.Text = "Button has not been clicked yet.";
}

Kita perlu menggunakan ViewDidLoad, alih-alih metode lain seperti Initialize, karena ViewDidLoad dipanggil setelah OS dimuat dan membuat instans Antarmuka Pengguna dari .storyboard file. Jika kami mencoba mengakses kontrol label sebelum .storyboard file dimuat sepenuhnya dan dibuat, kami akan mendapatkan NullReferenceException kesalahan karena kontrol label belum akan dibuat.

Selanjutnya, kita perlu menambahkan kode untuk merespons pengguna yang mengklik tombol . Tambahkan yang berikut ini ke kelas parsial ke yang kami buat:

partial void Clicked (UIButton sender)
{
    ClickedLabel.Text = string.Format("The button has been clicked {0} time{1}.", ++numberOfTimesClicked, (numberOfTimesClicked

Kode ini akan dipanggil kapan saja pengguna mengklik tombol kami.

Dengan segala sesuatu di tempat, kami sekarang siap untuk membangun dan menguji aplikasi Xamarin.tvOS kami.

Menguji Aplikasi

Saatnya untuk membangun dan menjalankan aplikasi kami untuk memastikan aplikasi berjalan seperti yang diharapkan. Kita dapat membangun dan menjalankan semua dalam satu langkah, atau kita dapat membangunnya tanpa menjalankannya.

Setiap kali kita membangun aplikasi, kita dapat memilih jenis build apa yang kita inginkan:

• Debug – Build debug dikompilasi ke dalam file '' (aplikasi) dengan metadata tambahan yang memungkinkan kita untuk men-debug apa yang terjadi saat aplikasi sedang berjalan.
• Rilis – Build rilis juga membuat file '', tetapi tidak menyertakan informasi debug, sehingga lebih kecil dan dijalankan lebih cepat.

Anda dapat memilih jenis build dari Pemilih Konfigurasi di sudut kiri atas layar Visual Studio untuk Mac:

Membangun Aplikasi

Dalam kasus kami, kami hanya ingin build debug, jadi mari kita pastikan debug dipilih. Mari kita buat aplikasi terlebih dahulu dengan menekan ⌘B, atau dari menu Build , pilih Bangun Semua.

Jika tidak ada kesalahan, Anda akan melihat pesan Build Berhasil di bilah status Visual Studio untuk Mac. Jika ada kesalahan, tinjau proyek Anda dan pastikan Anda telah mengikuti langkah-langkahnya dengan benar. Mulailah dengan mengonfirmasi bahwa kode Anda (baik di Xcode maupun di Visual Studio untuk Mac) cocok dengan kode dalam tutorial.

Menjalankan Aplikasi

Untuk menjalankan aplikasi, kami memiliki tiga opsi:

• Tekan ⌘+Enter.
• Dari menu Jalankan , pilih Debug.
• Klik tombol Putar di toolbar Visual Studio untuk Mac (tepat di atas Penjelajah Solusi).

Aplikasi akan membangun (jika belum dibangun), mulailah dalam mode debug, Simulator tvOS akan dimulai dan aplikasi akan meluncurkan dan menampilkan jendela antarmuka utamanya:

Dari menu Perangkat Keras pilih Tampilkan Apple TV Remote sehingga Anda dapat mengontrol simulator.

Menggunakan jarak jauh Simulator, jika Anda mengklik tombol beberapa kali label harus diperbarui dengan hitungan:

Selamat! Kami membahas banyak hal di sini, tetapi jika Anda mengikuti tutorial ini dari awal hingga akhir, Anda sekarang harus memiliki pemahaman yang kuat tentang komponen aplikasi Xamarin.tvOS serta alat yang digunakan untuk membuatnya.

Di mana Berikutnya?

Mengembangkan app Apple TV menghadirkan beberapa tantangan karena terputusnya sambungan antara pengguna dan antarmuka (berada di seberang ruangan yang tidak ada di tangan pengguna) dan batasan tempat tvOS pada ukuran dan penyimpanan aplikasi.

Akibatnya, kami sangat menyarankan Anda membaca dokumen berikut sebelum melompat ke desain aplikasi Xamarin.tvOS:

• Pengantar tvOS 9 - Artikel ini memperkenalkan semua API dan fitur baru dan yang dimodifikasi yang tersedia di tvOS 9 untuk pengembang Xamarin.tvOS.
• Bekerja dengan Navigasi dan Fokus – Pengguna aplikasi Xamarin.tvOS Anda tidak akan berinteraksi dengan antarmukanya secara langsung seperti halnya iOS tempat mereka mengetuk gambar di layar perangkat, tetapi secara tidak langsung dari seberang ruangan menggunakan Siri Remote. Artikel ini membahas konsep Fokus dan cara penggunaannya untuk menangani Navigasi di Antarmuka Pengguna aplikasi Xamarin.tvOS.
• Pengontrol Jarak Jauh dan Bluetooth Siri – Cara utama pengguna akan berinteraksi dengan Apple TV, dan aplikasi Xamarin.tvOS Anda, adalah melalui Siri Remote yang disertakan. Jika aplikasi Anda adalah game, Anda dapat secara opsional membangun dukungan untuk pihak ke-3, Made For iOS (MFI) Bluetooth Game Controllers di aplikasi Anda juga. Artikel ini membahas dukungan pengontrol game Siri Remote dan Bluetooth baru di aplikasi Xamarin.tvOS Anda.
• Sumber Daya dan Penyimpanan Data – Tidak seperti perangkat iOS, Apple TV baru tidak menyediakan penyimpanan lokal yang persisten untuk aplikasi tvOS. Akibatnya, jika aplikasi Xamarin.tvOS Anda perlu menyimpan informasi (seperti preferensi pengguna) aplikasi tersebut harus menyimpan dan mengambil data tersebut dari iCloud. Artikel ini membahas cara bekerja dengan sumber daya dan penyimpanan data persisten di aplikasi Xamarin.tvOS.
• Bekerja dengan Ikon dan Gambar – Membuat ikon dan citra yang menawan adalah bagian penting untuk mengembangkan pengalaman pengguna yang imersif untuk app Apple TV Anda. Panduan ini akan membahas langkah-langkah yang diperlukan untuk membuat dan menyertakan aset grafis yang diperlukan untuk aplikasi Xamarin.tvOS Anda.
• Antarmuka Pengguna – Cakupan Pengalaman Pengguna Umum (UX) termasuk kontrol Antarmuka Pengguna (UI), gunakan prinsip desain Antarmuka Xcode dan UX saat bekerja dengan Xamarin.tvOS.
• Penyebaran dan Pengujian – Bagian ini mencakup topik yang digunakan untuk menguji aplikasi serta cara mendistribusikannya. Topik di sini mencakup hal-hal seperti alat yang digunakan untuk penelusuran kesalahan, penyebaran ke penguji, dan cara menerbitkan aplikasi ke Apple TV App Store.

Jika Anda mengalami masalah saat bekerja dengan Xamarin.tvOS, silakan lihat dokumentasi Pemecahan Masalah kami untuk daftar tentang masalah dan solusi yang diketahui.

Ringkasan

Artikel ini menyediakan mulai cepat untuk mengembangkan aplikasi untuk tvOS dengan Visual Studio untuk Mac dengan membuat aplikasi Hello, tvOS sederhana. Ini mencakup dasar-dasar provisi perangkat tvOS, pembuatan antarmuka, pengkodian untuk tvOS dan pengujian pada simulator tvOS.

Link Terkait

• tvOS
• Panduan Antarmuka Manusia tvOS
• Panduan Pemrograman Aplikasi untuk tvOS
• Membangun aplikasi untuk tvOS dengan Xamarin (video)