Di Android, hampir semuanya adalah sebuah **resource**. [Mendefinisikan resource](http://developer.android.com/guide/topics/resources/providing-resources.html) yang nantinya dapat [diakses](http://developer.android.com/guide/topics/resources/accessing-resources.html) di aplikasi merupakan bagian mendasar dari proses pengembangan aplikasi Android.

*Resource* dapat dipakai untuk mendefinisikan *color* (warna), *image* (gambar), *layout* (tata letak), *menu*, dan nilai *string*. Nilai-nilai di dalam *resource* ini mencegah kita dari menuliskannya secara langsung (*hardcoded*). Semua yang didefinisikan dapat dipanggil dari manapun didalam *project* yang dibuat. Contoh yang paling umum dan paling sederhana adalah penggunaan **string resource** untuk lokalisasi teks yang fleksibel.

## Jenis-jenis Resource

Berikut ini jenis *resource* yang paling umum dipakai di aplikasi Android:

| **Nama**             | **Folder** | **Deskripsi**                            |
| -------------------- | ---------- | ---------------------------------------- |
| *Property Animation* | animator   | berkas XML yang mendefinisikan properti animasi |
| *Tween Animation*    | anim       | berkas XML yang mendefinisikan *tween* animasi |
| *Drawable*           | drawable   | berkas gambar berbentuk Bitmap atau XML  |
| Layout               | layout     | berkas XML yang mendefinisikan antarmuka aplikasi |
| Menu                 | menu       | berkas XML yang mendefinisikan menu atau item action bar |
| Values               | values     | berkas XML yang menyimpan nilai seperti string, integer, dan color. |

Di bawah ini merupakan berkas-berkas yang tersimpan di folder `values`:

| Nama       | File                     | Deskripsi                                |
| ---------- | ------------------------ | ---------------------------------------- |
| Color      | `res/values/colors.xml`  | Mendefinisikan [warna](http://developer.android.com/guide/topics/resources/more-resources.html#Color) |
| Dimensions | `res/values/dimens.xml`  | Mendefinisikan [ukuran](http://developer.android.com/guide/topics/resources/more-resources.html#Dimension) seperti padding, margin, font, dll. |
| Strings    | `res/values/strings.xml` | Mendefinisikan [teks](http://developer.android.com/guide/topics/resources/string-resource.html) misalnya untuk *placeholder* atau nama aplikasi |
| Styles     | `res/values/styles.xml`  | Mendefinisikan *[style](http://developer.android.com/guide/topics/resources/style-resource.html)* misalnya warna untuk AppBar |

Untuk daftar jenis *resource* yang lebih lengkap, silahkan kunjungi halaman [berikut](http://developer.android.com/guide/topics/resources/providing-resources.html).

## Membuat App Resource

### Membuat Sebuah String Resource

Untuk setiap teks yang ingin ditampilkan di aplikasi (misalnya label sebuah Button dan teks didalam TextView), kita pertama harus mendefinisikan dulu teks tersebut di dalam berkas `/res/avlues/strings.xml`. Setiap nilai yang ditambahkan di dalam berkas tersebut terdiri atas key (sebagai id untuk teks) dan nilai dari teks itu sendiri. Contoh, apabila kita ingin membuat sebuah Button dengan teks "Submit", berikut ini nilai yang mesti ditambahkan ke `strings.xml`:

```
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello!</string>
    <string name="submit_label">Submit</string>
</resources>
```

Sekarang kapanpun kita memanggil id `submit_label`, kita akan mendapatkan teks "Submit". Kita dapat menampilkan data yang lebih kompleks (misalnya teks yang mengandung kode html atau karakter khusus) menggunakan CDATA sebagai berikut:

```
<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string name="feedback_label">
  <![CDATA[
    Please <a href="http://highlight.com">let us know</a> if you have feedback on this or if 
    you would like to log in with another identity service. Thanks! This is a longer string!  
  ]]>
  </string>
</resources>
```

### Mereferensikan App Resource

Sekarang setelah kita mendefinisikan string resource yang dibutuhkan, kita dapat memanggilnya dari Java atau XML lain. Untuk mengaksesnya dari file XML lain, cukup panggil menggunakan simbol `@`:

```
<Button
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="@string/submit_label" />
```

Untuk mengakses resource ini dari Java, maka kita perlu memanggil metode `getResource.getString` atau `getString` dengan memanggil id-nya:

```
String submitText = getResources().getString(R.string.submit_label)
```

Pola yang sama dapat kita pakai untuk memanggil semua jenis *resource*.

### Mendefinisikan Color Resource

Selain string *resource* seperti contoh di atas, kita juga dapat membuat *color resource* sebagai berikut:

```
<?xml version="1.0" encoding="utf-8"?>
<resources>
   <color name="white">#FFFFFF</color>
   <color name="yellow">#FFFF00</color>
   <color name="fuchsia">#FF00FF</color>
</resources>
```

Mengaksesnya di kode Java dengan cara sebagai berikut:

```
// cara pemanggilan getResources().getColor() sudah ditinggalkan
// Resources res = getResources();
// int color = res.getColor(R.color.yellow); 

// Gunakan ContextCompatResources untuk menggantikan getColor()
int color = ContextCompat.getColor(context, R.color.yellow);
```

Dan memanggilkan *color resource* dari berkas XML lain dengan cara:

```
<TextView
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:textColor="@color/fuchsia"
    android:text="Hello"/>
```

### Mendefinisikan Dimension Resource

Saat menentukan ukuran kita menggunakan beberapa unit misalnya 16dp untuk ukuran margin dan 12sp untuk ukuran font. Dimensi ini mesti kita definisikan di berkas `dimens.xml` dengan cara:

```
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <dimen name="textview_height">25dp</dimen>
    <dimen name="textview_width">150dp</dimen>
    <dimen name="ball_radius">30dp</dimen>
    <dimen name="font_size">16sp</dimen>
</resources>
```

Pemanggilannya di Java:

```
Resources res = getResources();
float fontSize = res.getDimension(R.dimen.font_size);
```

Sedangkan di XML:

```
<TextView
    android:layout_height="@dimen/textview_height"
    android:layout_width="@dimen/textview_width"
    android:textSize="@dimen/font_size"/>
```

### Pemanggilan Resource Secara Dinamis

Dalam beberapa kasus kita ingin mengambil *resource* secara dinamis tanpa menuliskan manual `id`-nya. Contoh, kita ingin mengambil teks dari "submit_label" berdasarkan namanya. Nilai yang diinginkan bisa kita dapatkan menggunakan metode `getIdentifier` di dalam sebuah Activity:

```
public String getStringValue(String key) {
    // Mengambil resource id
    String packageName = getBaseContext().getPackageName();
    Resources resources = getBaseContext().getResources();
    int stringId = resources.getIdentifier(key, "string", packageName);
    if (stringId == 0) { return null; }
    // Mengembalikan nilai string berdasarkan resource id
    return resources.getString(stringId);
}
```

Sekarang kita bisa mereferensikan string resource secara dinamis dengan cara:

```
public String myKey = "submit_label"; // Maksudnya R.string.submit_label
public String myStringValue = getStringValue(myKey); // Mengambil teks berdasarkan id
```

Teknik di atas dapat diaplikasikan ke jenis *resource* yang lain. Berikut ini contoh untuk mengambil view secara dinamis berdasarkan `id`-nya:

```
// getViewById("tvTest");
public View getViewById(String id) {
    // Retrieve the resource id
    String packageName = getBaseContext().getPackageName();
    Resources resources = getBaseContext().getResources();
    int viewId = resources.getIdentifier(id, "id", packageName);
    if (viewId == 0) { return null; }
    return findViewById(viewId);
}
```

## Membuat Resource Alternatif

### Responsive Design

Untuk membuat antarmuka yang menarik, penting bagi developer membuat aplikasi yang ia kembangkan dapat berjalan dengan baik di berbagai peragnkat. Untuk mencapai tujuan ini, kita pertama harus membagi jenis-jenis perangkat Android kedalam kategori berdasarkan besar layar sebagai berikut:

![](http://i.imgur.com/bLOO9e3.png)

Aplikasi harus didesain untuk berkerja di berbagai jenis lebar layar dan kerapatannya. 

### Menyediakan Resource Alternatif

Salah satu fitur paling *powerful* yang dapat dipakai developer adalah membuat *resource* alternatif berdasarkan ukuran layar, bahasa, kerapatan layar, dll. Beberapa penggunaannya yang paling umum adalah:

- Membuat layout yang berbeda untuk jenis perangkat yang berbeda (misalnya telepon vs tablet)
- Membuat *resource* String yang berbeda untuk bahasa yang berbeda (misal Bahasa Inggris vs Italia)
- Membuat *resource* drawable untuk kerapatan layar yang berbeda (lihat di bawah)
- Membuat style yang berbeda untuk sistem yang berbeda (Holo vs Material)
- Membuat layout yang berbeda untuk orientasi layar yang berbeda (portrait vs landscape)

Untuk mengkhususkan suatu *resource* alternatif, kita membuat direktori baru di dalam `res` dengan struktur `[resource]-[qualifier]`. *Qualifier* adalah target  yang ingin dikenai oleh *resource* alternatif. 

Contoh, bila ingin memastikan semua gambar dapat tersedia untuk segala jenis kerapatan layar dapat kita lakukan dengan membuat direktori `res/drawable-hdpi`, `res/drawable-xhdpi`, dan `res/drawable-xxhdpi` lalu mengisinya dengan gambar yang sama namun memiliki dimensi yang berbeda. Android akan memilih *resource* mana yang paling cocok untuk dipakai berdasarkan kerapatan layar perangkat yang sedang membuatnya. Struktur direktorinya dapat terlihat seperti berikut:

```
res/
    drawable/   
        icon.png
        background.png    
    drawable-hdpi/  
        icon.png
        background.png
```

![](http://developer.android.com/images/screens_support/screens-densities.png)

Perlu dicatat bahwa *resource* harus memiliki nama yang sama meski berada di folder yang berbeda.

### Resource Qualifiers

Android memiliki beberapa jenis *qualifier* yang berguna untuk menentukan *resource* mana yang harus digunakan pada perangkat tertentu. *Qualifier* yang paling umum dipakai adalah:

| Jenis Konfigurasi | Qualifier            | Deskripsi                                |
| ----------------- | -------------------- | ---------------------------------------- |
| Bahasa            | `en`, `id`, `fr`     | Kode bahasa                              |
| Ukuran Layar      | `sw480dp`, `sw600dp` | Ukuran minimum layar (tinggi atau lebar) |
| Orientasi Layar   | `port`, `land`       | Menentukan apakah layar berada di mode *portrait* atau *landscape* |
| Kerapatan Layar   | `hdpi`, `xhdpi`      | Kerapatan layar biasanya dipakai untuk gambar |
| Versi *Platform*  | `v7`, `v11`, `v21`   | Dipakai biasanya untuk *style*           |

Kita dapat memberikan beberapa *qualifier* untuk satu jenis *resource* yang dipisahkan dengan tanda `-`. Contoh, `drawable-en-sw600dp-ladn` akan mengaplikasikan *resource* pada perangkat tablet yang menggunakan Bahasa Inggris dengan ukuran layar minimal 600dp di orientasi *landscape*. Perlu dicatat bila menggunakan *multiple qualifier* untuk satu jenis *resource,* kita harus menambahkannya didirektori dalam urutan yang benar. Kunjungi halaman [berikut](http://developer.android.com/guide/topics/resources/providing-resources.html#AlternativeResources) untuk melihat seluruh *qualifier* yang tersedia. 

### Membuat Resource Alternatif

Di Android Studio, cara termudah untuk membuat *resource* alternatif adalah dengan melakukan klik kanan pada sebuah *subfolder resource* (misal, `layout`) lalu pilih **New > Layout resource file** untuk mendapatkan jendela baru dan menentukan *qualifier* yang diinginkan. 

![](http://i.imgur.com/cxeH3J1.gif)

Proses di atas akan membuat dua versi layout, satu untuk mode *portrait* dan satu lagi untuk mode *landscape*. Jika kita menambahkan label yang berbeda untuk layout yang kedua, kita akan melihat bahwa label tersebut secara otomatis tampil saat layar diputar. 

![](http://i.imgur.com/bRUzYLI.gif)

### Membaca Konfigurasi Qualifier Saat Runtime

Saat aplikasi sedang berjalan, kita dapat selalu memeriksa konfigurasi yang sedang berjalan (orientasi layar, ukuran layar, dll.) dengan mengakses objek Configuration melalui `getResources().getConfiguration()` di dalam sebuah Activity atau objek Context. Contoh, untuk membaca orientasi layar saat di dalam Activity, kita dapat melakukannya dengan cara:

```java
String image;
int orientation = getResources().getConfiguration().orientation;
if (orientation == Configuration.ORIENTATION_PORTRAIT) {
   image = "image_portrait.png";
   // ...
} else if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
   image = "image_landscape.png";
   // ...
}
```

  Kita juga dapat menjalankan perintah `getContext().getResources().getConfiguration()` jika tidak berada di dalam sebuah Activity namun memiliki objek Context.

### Membuat Layout Alternatif

Penyediaan layout alternatif biasanya dilakukan untuk membuat layout yang berbeda saat aplikasi dijalankan di perangkat handphone atau tablet. Penentuan ukuran ini dapat dilakukan dengan menggunakan *smallest width qualifier* atau `sw`. Struktur foldernya dapat terlihat sebagai berikut:

```
res/
    layout/   
        activity_main.xml
        item_photo.xml    
    layout-sw600dp/ 
        activity_main.xml
    layout-sw600dp-land/
        activity_main.xml 
    layout-sw720dp/ 
        activity_main.xml
        item_photo.xml
    layout-land/
        activity_main.xml
        item_photo.xml
```

Secara umum perangkat handphone dan phablet berada antara `sw240` sampai `sw480`. Tablet berlayar 7" berlayar`sw600` dan tablet berlayar 10" berukuran `sw720`. Berikut ilustrasinya:

![](http://i.imgur.com/KS5xs0n.png)

Sumber: 

[Codepath](https://guides.codepath.com/android/Understanding-App-Resources#providing-alternate-resources)

Memahami App Resource di Android

GenAI Video Fest adalah ajang kompetisi video kreatif yang diselenggarakan oleh CODEPOLITAN bekerjasama dengan Alibaba Cloud.

Kami menantang kreator, tech-enthusiast, dan siapa saja untuk mendobrak batas imajinasi menggunakan teknologi Generative AI terbaru. Di sini, kamu wajib menggunakan WAN Model Studio dari Alibaba Cloud sebagai tools utama untuk menghasilkan karya videomu (bisa dikombinasikan dengan tools editing lainnya).

Tunjukkan pada dunia bagaimana teknologi dan kreativitas bisa bersatu menciptakan karya visual yang berdampak!

Kategori Kompetisi
Pilih satu dari empat tema besar ini untuk karyamu:
* Humanity (Kemanusiaan): Cerita yang menyentuh hati, sosial, dan kepedulian antar sesama.
* Sports (Olahraga): Energi, semangat juang, dan dinamika dunia olahraga.
* Entertainment (Hiburan): Komedi, musik, video klip, atau parodi yang menghibur.
* Science (Sains): Visualisasi masa depan, teknologi, alam semesta, atau penemuan ilmiah.

Total Prize Pool senilai Rp 250.000.000 menunggu para pemenang!
* Top Winners Rewards: Uang Tunai, Alibaba Cloud Credits (hingga $500), Merchandise Eksklusif, dan SWAG CODEPOLITAN.
* Lucky Draw Event: Kesempatan menang hadiah tambahan bagi peserta yang beruntung.
* Massive Exposure: Karya terbaik akan di-highlight di media sosial CODEPOLITAN, Alibaba Cloud, dan channel industri kreatif lainnya.
* Special Access (Khusus Alumni RuangAI): Dapatkan 2 Token untuk klaim Kelas Spesialisasi di RuangAI secara gratis.

Jangan sampai ketinggalan tanggal penting ini:
* Pendaftaran & Submission: 23 Desember 2024 - 23 Januari 2025
* Penjurian (Judging Phase): 24 - 26 Januari 2025
* Pengumuman Pemenang: 27 Januari 2025

Cara Ikutan:
1. Daftar: Klik tombol "Daftar Sekarang" dan pastikan kamu punya akun RuangAI.
2. Join Discord: Masuk ke server Discord komunitas untuk info teknis dan diskusi.
3. Create: Buat video kreatifmu menggunakan WAN Model Studio (Alibaba Cloud) sesuai kategori pilihan.
4. Upload & Submit: Unggah videomu ke media sosial (IG/TikTok/YouTube) dan submit link karyamu di halaman submission RuangAI.

Ikuti kompetisi video Generative AI terbesar dari CODEPOLITAN dan Alibaba Cloud! Gunakan teknologi WAN Model Studio untuk menyulap ide liarmu menjadi visual memukau. Rebut total hadiah senilai Rp 250.000.000!

GenAI Video Fest

Beasiswa Basic Cybersecurity adalah program inisiatif dari JagoanSiber yang dirancang untuk membuka wawasan masyarakat luas tentang dunia keamanan digital. Program ini hadir untuk menjawab kebutuhan talenta keamanan siber yang tinggi, dimulai dengan membangun pemahaman fundamental yang kokoh.

Program ini berbentuk Kelas Online Belajar Mandiri (Self-Paced Learning) berbasis video. Peserta diberikan keleluasaan penuh untuk mengakses materi kapan saja dan di mana saja tanpa terikat jadwal, sehingga sangat fleksibel bagi pelajar, mahasiswa, maupun pekerja profesional.

Kelebihan utama program ini adalah aksesnya yang 100% GRATIS dan terbuka untuk siapa saja tanpa syarat latar belakang IT. Peserta akan dibimbing langsung oleh Mahrus Qusaery, seorang praktisi keamanan siber berpengalaman, yang akan mengupas tuntas materi dasar yang krusial.

Program beasiswa kelas online gratis untuk mempelajari dasar keamanan siber dari nol. Belajar mandiri berbasis video langsung dari praktisi ahli, Mahrus Qusaery.

Memahami App Resource di Android

Learning

KelasFullstack

RuangAI

JagoanSiber

Baca Artikel Lainnya

Hour of Code, Belajar Coding Satu Jam

Jangan Lewatkan, Jogja Geek Job Fair #2 Digelar Lagi Minggu Ini

Wawancara Bersama Luri Darmawan Pembuat AKSI IDE

io.js, Framework JavaScript yang Kompatibel dengan Node.js dan npm

CodeCombat, Belajar Coding Sambil Bermain Game

Mengenal Meteor, Framework JavaScript yang Sedang Naik Daun