HarmonyOS Preferences ile Kişiselleştirilmiş Ayar Depolama Rehberi

HarmonyOS uygulamalarınızda kullanıcıların kişisel ayarlarını güvenle ve etkili bir şekilde nasıl depolayacağınızı merak mı ediyorsunuz? Preferences API ile cihazlar arası senkronizasyon ve veri bütünlüğünü sağlayın, kullanıcı deneyimini zirveye taşıyın.

Günümüz dijital dünyasında, bir uygulamanın başarısı sadece sunduğu temel özelliklerle sınırlı değildir. Kullanıcılar, kullandıkları araçların kendi ihtiyaçlarına ve zevklerine göre şekillenebilmesini beklerler. Bu kişisel dokunuşlar, kullanıcının uygulamayla kurduğu bağı güçlendiren kritik unsurlardır; sadakati, kullanım sıklığını ve genel memnuniyeti doğrudan etkiler. Örneğin, bir uygulamanın tema tercihi, bildirim ayarları veya favori listeleri gibi kişiselleştirilebilir seçenekler, uygulamanın “kendine ait” hissetmesini sağlar.

Peki, bir geliştirici olarak bu kişiselleştirme beklentisini nasıl karşılayabilirsiniz? Kullanıcıların yaptığı seçimleri, uygulama kapatılıp açıldığında bile kaybolmadan nasıl saklayabilirsiniz? İşte bu sorunun cevabı, veri kalıcılığı (data persistence) kavramında gizlidir. Kullanıcı ayarlarının kalıcı olarak depolanması, uygulama deneyiminin tutarlı ve kesintisiz olmasının temelidir. HarmonyOS gibi modern işletim sistemleri, bu ihtiyacı karşılamak üzere çeşitli mekanizmalar sunar. Bu makalede, HarmonyOS geliştiricileri için kullanıcı kişiselleştirmesini kolayca yönetmelerini sağlayan güçlü bir araç olan Preferences API’sine odaklanacağız. Preferences, anahtar-değer (key-value) çiftleri şeklinde küçük boyutlu verileri depolamak için idealdir; özellikle kullanıcı arayüzü ayarları, oturum bilgileri veya basit uygulama tercihleri gibi durumlar için biçilmiş kaftandır. Bu sayede, kullanıcılar her seferinde sıfırdan başlamak zorunda kalmazlar, bu da uygulamanın kullanım kolaylığını önemli ölçüde artırır. Dahası, dağıtılmış yetenekleri sayesinde HarmonyOS’ta depolanan Preferences verileri, kullanıcıların farklı HarmonyOS cihazları arasında sorunsuz bir şekilde senkronize edilebilir, böylece kişiselleştirilmiş deneyim her cihazda devam eder. Bu makalede, Preferences API’nin temelden ileri seviyeye tüm yönlerini ele alacak, kod örnekleriyle uygulamanıza nasıl entegre edeceğinizi gösterecek ve en iyi pratikleri paylaşarak uygulamanızın kalitesini artırmanıza yardımcı olacağız.

HarmonyOS Preferences Nedir ve Temel Kullanım Senaryoları Nelerdir?

HarmonyOS ekosisteminde, uygulama içi ayarların ve küçük boyutlu verilerin kalıcı olarak depolanması için kullanılan birincil mekanizmalardan biri Preferences API’sidir. Basitçe ifade etmek gerekirse, Preferences, uygulama verilerini anahtar-değer çiftleri (key-value pairs) şeklinde depolayan hafif bir depolama çözümüdür. Bu yapısı itibarıyla, bir veriyi depolamak için benzersiz bir anahtar (string) ve bu anahtara karşılık gelen bir değer (int, string, boolean, float, long gibi temel veri tipleri) kullanırsınız. Bu yaklaşım, veriye hızlı erişim sağlar ve özellikle karmaşık veri yapıları yerine basit, doğrudan erişilebilir bilgilere ihtiyaç duyulduğunda oldukça etkilidir.

Preferences’ın en belirgin özelliklerinden biri, depoladığı verilerin uygulama kapatılsa veya cihaz yeniden başlatılsa bile kalıcı olmasıdır. Bu kalıcılık, kullanıcı deneyiminin sürekliliği açısından hayati öneme sahiptir. Örneğin, bir kullanıcının tema tercihi, dil ayarı veya bildirim tercihleri gibi bilgiler, her uygulama başlatıldığında yeniden ayarlanmak zorunda kalınmadan hatırlanır. Bu, kullanıcının uygulamanızla etkileşimini çok daha akıcı ve kişisel hale getirir. Preferences verileri genellikle uygulama özelinde depolanır ve diğer uygulamalar tarafından doğrudan erişilemez, bu da belirli bir güvenlik ve izolasyon katmanı sağlar.

Peki, HarmonyOS Preferences’ı hangi senaryolarda kullanmalıyız? İşte bazı temel kullanım alanları:

• Kullanıcı Arayüzü Ayarları: Uygulamanın tema rengi (açık/koyu mod), yazı tipi boyutu, dil seçimi gibi ayarları depolamak.
• Oturum Yönetimi: Kullanıcının oturum açıp açmadığı bilgisi, son giriş zamanı, basit token’lar (hassas veriler için daha güvenli depolama yöntemleri tercih edilmeli) gibi bilgileri saklamak.
• Uygulama İçi Tercihler: Bildirimlerin açık/kapalı olması, belirli özelliklerin etkinleştirilip etkinleştirilmediği, ilk çalıştırma kılavuzunun gösterilip gösterilmediği gibi uygulama bazlı tercihleri depolamak.
• Geçici Durumlar: Kullanıcının en son kaldığı ekran gibi geçici durum bilgilerini saklamak.

Preferences, verileri dahili depolama biriminde genellikle XML formatında veya benzer bir yapılandırma dosyasında saklar. Bu dosyalar, uygulamanızın veri dizininde bulunur. HarmonyOS’un dağıtılmış yetenekleriyle birlikte kullanıldığında, Preferences verileri, aynı kullanıcıya ait farklı HarmonyOS cihazları arasında da otomatik olarak senkronize edilebilir. Bu, kullanıcının telefonunda yaptığı bir ayarın, tabletinde veya akıllı saatinde de geçerli olmasını sağlayarak tutarlı bir çoklu cihaz deneyimi sunar. Ancak, büyük veri kümeleri, veritabanı benzeri ilişkisel yapılar veya güvenlik açısından çok hassas bilgiler için Preferences yerine daha gelişmiş depolama çözümlerini (örneğin, Distributed Data Service, ObjectStore veya veritabanları) tercih etmek daha uygun olacaktır. Preferences’ın temel gücü, basitliği, hızı ve kullanım kolaylığıdır.

HarmonyOS Preferences ile Temel Veri Depolama Nasıl Yapılır? Adım Adım Rehber

Şimdi gelelim işin uygulamalı kısmına! HarmonyOS uygulamanızda Preferences API’sini kullanarak kullanıcı ayarlarını nasıl depolayacağınızı adım adım inceleyelim. Bu bölümde, Preferences örneği oluşturmaktan, veri yazmaya, okumaya ve silmeye kadar temel işlemleri ele alacağız.

Preferences kullanmaya başlamadan önce, bir Preferences örneği elde etmeniz gerekir. Bu, genellikle bir Context veya Ability örneği üzerinden yapılır ve bir dosya adı belirterek belirli bir tercih dosyasını işaret edersiniz. Bu dosya adı, depolamak istediğiniz ayarlar grubu için benzersiz bir tanımlayıcı görevi görür. Aşağıdaki örnek, bir Preferences örneğinin nasıl alınacağını ve temel veri tiplerinin nasıl depolanacağını göstermektedir. HarmonyOS’ta bu işlemler genellikle asenkron olarak gerçekleştirilir, bu da UI’ın donmasını engeller ve daha akıcı bir kullanıcı deneyimi sunar.

import preferences from '@ohos.data.preferences';
import common from '@ohos.app.ability.common';

const PREFS_FILE_NAME = 'user_settings';

interface UserSettings {
    themeMode: number; // 0: System, 1: Light, 2: Dark
    notificationsEnabled: boolean;
    username: string;
    fontSize: number; // float
}

class PreferencesService {
    private context: common.AbilityContext;
    private preferences: preferences.Preferences;

    constructor(context: common.AbilityContext) {
        this.context = context;
    }

    async loadPreferences(): Promise {
        try {
            this.preferences = await preferences.getPreferences(this.context, PREFS_FILE_NAME);
            console.log('Preferences başarıyla yüklendi.');
        } catch (err) {
            console.error(Preferences yüklenirken hata oluştu: ${JSON.stringify(err)});
        }
    }

    getPreferencesInstance(): preferences.Preferences {
        return this.preferences;
    }

    async saveSettings(settings: UserSettings): Promise {
        if (!this.preferences) {
            console.error('Preferences henüz yüklenmedi.');
            return;
        }
        try {
            await this.preferences.put('theme_mode', settings.themeMode);
            await this.preferences.put('notifications_enabled', settings.notificationsEnabled);
            await this.preferences.put('username', settings.username);
            await this.preferences.put('font_size', settings.fontSize);
            await this.preferences.flush(); // Değişiklikleri kalıcı hale getirir
            console.log('Ayarlar başarıyla kaydedildi.');
        } catch (err) {
            console.error(Ayarlar kaydedilirken hata oluştu: ${JSON.stringify(err)});
        }
    }

    async loadSettings(): Promise {
        if (!this.preferences) {
            console.error('Preferences henüz yüklenmedi. Varsayılan ayarlar döndürülecek.');
            return {
                themeMode: 0,
                notificationsEnabled: true,
                username: 'Misafir',
                fontSize: 16.0
            };
        }
        try {
            const themeMode = await this.preferences.get('theme_mode', 0) as number;
            const notificationsEnabled = await this.preferences.get('notifications_enabled', true) as boolean;
            const username = await this.preferences.get('username', 'Misafir') as string;
            const fontSize = await this.preferences.get('font_size', 16.0) as number;

            console.log('Ayarlar başarıyla okundu.');
            return { themeMode, notificationsEnabled, username, fontSize };
        } catch (err) {
            console.error(Ayarlar okunurken hata oluştu: ${JSON.stringify(err)});
            return {
                themeMode: 0,
                notificationsEnabled: true,
                username: 'Misafir',
                fontSize: 16.0
            };
        }
    }

    async deleteSetting(key: string): Promise {
        if (!this.preferences) return;
        try {
            await this.preferences.delete(key);
            await this.preferences.flush();
            console.log(Ayarlar başarıyla silindi: ${key});
        } catch (err) {
            console.error(Ayar silinirken hata oluştu: ${JSON.stringify(err)});
        }
    }

    async clearAllSettings(): Promise {
        if (!this.preferences) return;
        try {
            await this.preferences.clear();
            await this.preferences.flush();
            console.log('Tüm ayarlar başarıyla temizlendi.');
        } catch (err) {
            console.error(Ayarlar temizlenirken hata oluştu: ${JSON.stringify(err)});
        }
    }
}
/* HarmonyOS Ability'si içinden kullanım örneği
import Ability from '@ohos.app.ability.Ability';
export default class MyAbility extends Ability {
    private preferencesService: PreferencesService;
    onCreate(want, launchParam) {
        this.preferencesService = new PreferencesService(this.context);
        this.initSettings();
    }
    async initSettings() {
        await this.preferencesService.loadPreferences();
        const newSettings: UserSettings = { themeMode: 2, notificationsEnabled: false, username: 'JaneDoe', fontSize: 18.5 };
        await this.preferencesService.saveSettings(newSettings);
        const currentSettings = await this.preferencesService.loadSettings();
        console.log(Mevcut Tema Modu: ${currentSettings.themeMode});
    }
}
*/

Yukarıdaki kod bloğunda, PreferencesService adında bir sınıf oluşturarak Preferences işlemlerini merkezi bir şekilde yönetiyoruz. loadPreferences() metodu ile asenkron olarak bir Preferences örneği alıyor ve daha sonra saveSettings() ile verileri kaydediyor, loadSettings() ile okuyoruz. put metotları, anahtar-değer çiftlerini Preferences'a yazar. HarmonyOS'ta bu işlemler Promise tabanlı olduğu için async/await yapısı ile kolayca yönetilebilir. get metotları ise, belirtilen anahtara karşılık gelen değeri okur; eğer anahtar bulunamazsa, ikinci parametre olarak geçilen varsayılan değeri döndürür. Bu, uygulamanızın ilk kez çalıştırıldığında veya belirli bir ayar henüz kaydedilmediğinde tutarlı bir davranış sergilemesini sağlar. Verileri kalıcı hale getirmek için flush() metodunu çağırmak önemlidir. Bu metod, bellekteki değişiklikleri depolama birimine yazar. Ayrıca, delete(key) metodu ile belirli bir anahtara ait veriyi silerken, clear() metodu ile ilgili Preferences dosyasındaki tüm verileri silebilirsiniz. Her iki işlemden sonra da değişikliklerin kalıcı olması için flush() metodunu çağırmayı unutmamak gerekir. Bu temel adımlar, HarmonyOS uygulamanızda kullanıcı kişiselleştirmesini yönetmek için sağlam bir temel oluşturacaktır.

Uygulamanızın Ayarlarını Dinamik Hale Getirmek: Veri Güncelleme ve İzleme Mekanizmaları

Kullanıcıların uygulama içindeki ayarları sadece depolamak yeterli değildir; bu ayarlar değiştiğinde kullanıcı arayüzünü (UI) veya uygulamanın davranışını anında güncellemek de büyük önem taşır. Örneğin, kullanıcı koyu temayı seçtiğinde uygulamanızın anında koyu tema moduna geçmesi beklenir. HarmonyOS Preferences API'si, bu dinamik güncellemeleri yönetmek için oldukça kullanışlı bir mekanizma sunar: değişim dinleyicileri (change listeners). Bu sayede, bir Preference değeri değiştiğinde uygulamanızın ilgili bölümlerini otomatik olarak güncelleyebilirsiniz.

Bir Preferences dosyasındaki herhangi bir değer değiştiğinde bilgilendirilmek için preferences.onChangeListener metodunu kullanabilirsiniz. Bu metod, bir callback fonksiyonu alır ve bu fonksiyon, dosya içindeki bir anahtarın değeri değiştiğinde tetiklenir. Bu sayede, değişen ayara göre uygulamanızın UI'ını veya iç mantığını güncelleyebilirsiniz. İşte bir örnek:

import preferences from '@ohos.data.preferences';
import common from '@ohos.app.ability.common';
import { PREFS_FILE_NAME, PreferencesService, UserSettings } from './PreferencesService';

interface UIUpdater {
    updateTheme(themeMode: number): void;
    updateNotificationsStatus(enabled: boolean): void;
    updateUsername(username: string): void;
}

class SettingsManager {
    private preferencesService: PreferencesService;
    private uiUpdater: UIUpdater;

    constructor(context: common.AbilityContext, uiUpdater: UIUpdater) {
        this.preferencesService = new PreferencesService(context);
        this.uiUpdater = uiUpdater;
        this.init();
    }

    private async init() {
        await this.preferencesService.loadPreferences();
        this.setupPreferenceChangeListener();
        this.applyCurrentSettingsToUI();
    }

    private setupPreferenceChangeListener(): void {
        this.preferencesService.getPreferencesInstance().onChangeListener((key: string) => {
            console.log(Preferences değişti: Anahtar -> ${key});
            this.handlePreferenceChange(key);
        });
    }

    private async handlePreferenceChange(key: string): Promise {
        const currentSettings = await this.preferencesService.loadSettings();
        switch (key) {
            case 'theme_mode': this.uiUpdater.updateTheme(currentSettings.themeMode); break;
            case 'notifications_enabled': this.uiUpdater.updateNotificationsStatus(currentSettings.notificationsEnabled); break;
            case 'username': this.uiUpdater.updateUsername(currentSettings.username); break;
            default: console.log(Bilinmeyen anahtar değişti: ${key}); break;
        }
    }

    private async applyCurrentSettingsToUI(): Promise {
        const currentSettings = await this.preferencesService.loadSettings();
        this.uiUpdater.updateTheme(currentSettings.themeMode);
        this.uiUpdater.updateNotificationsStatus(currentSettings.notificationsEnabled);
        this.uiUpdater.updateUsername(currentSettings.username);
    }

    removeChangeListener(): void {
        this.preferencesService.getPreferencesInstance().offChangeListener();
        console.log('Preferences değişim dinleyicisi kaldırıldı.');
    }
}
/* UIUpdater arayüzünü uygulayan bir örnek sınıf (örneğin bir @Component içinde)
import { UIAbilityContext } from '@ohos.app.ability.UIAbility';
@Entry @Component
struct MySettingsPage implements UIUpdater {
    @State themeMode: number = 0; @State notificationsEnabled: boolean = true; @State username: string = 'Misafir';
    private settingsManager: SettingsManager; private abilityContext: UIAbilityContext;
    aboutToAppear() {
        this.abilityContext = getContext(this) as UIAbilityContext;
        this.settingsManager = new SettingsManager(this.abilityContext, this);
    }
    updateTheme(themeMode: number): void { this.themeMode = themeMode; console.log(UI teması güncellendi: ${themeMode}); }
    updateNotificationsStatus(enabled: boolean): void { this.notificationsEnabled = enabled; console.log(UI bildirim durumu güncellendi: ${enabled}); }
    updateUsername(username: string): void { this.username = username; console.log(UI kullanıcı adı güncellendi: ${username}); }
    build() {
        Column() {
            Text(Tema Modu: ${this.themeMode === 0 ? 'Sistem' : this.themeMode === 1 ? 'Aydınlık' : 'Karanlık'}).fontSize(20).margin(10)
            Button('Koyu Tema Yap').onClick(async () => { await this.settingsManager.preferencesService.saveSettings({ ...await this.settingsManager.preferencesService.loadSettings(), themeMode: 2 }); }).margin(10)
        }.width('100%').height('100%')
    }
    aboutToDisappear() { this.settingsManager.removeChangeListener(); }
}
*/

Bu örnekte, SettingsManager sınıfı, PreferencesService'i kullanarak ayarları yönetirken, UIUpdater arayüzü sayesinde ayarlar değiştiğinde UI komponentlerine bildirim gönderir. onChangeListener metodu, Preferences dosyasındaki herhangi bir değer değiştiğinde tetiklenir ve değişen anahtarın adını callback fonksiyonuna iletir. Bu anahtar bilgisiyle, hangi ayarın değiştiğini anlayıp sadece o ayarla ilgili UI elementini güncellemek mümkündür. HarmonyOS'ta, bir @Component içinde @State dekoratörü ile tanımlanmış değişkenler, değerleri değiştiğinde otomatik olarak UI'ı yeniden render eder, bu da dinamik UI güncellemelerini oldukça kolaylaştırır. Bu yaklaşımla, kullanıcı ayarlarında yapılan değişiklikler anında ve etkileşimli bir şekilde uygulamaya yansıtılır. Unutulmamalıdır ki, onChangeListener'ı uygulamanın yaşam döngüsüne uygun olarak (örneğin, bir Ability veya Component oluşturulduğunda kaydolup, yok edildiğinde kaydını silerek) yönetmek, bellek sızıntılarını önlemek ve uygulamanın performansını korumak için kritik öneme sahiptir. Bu mekanizma, kullanıcı deneyimini zenginleştiren, yanıt veren ve akıcı uygulamalar oluşturmanıza olanak tanır.

Dağıtılmış Preferences ile Çoklu Cihaz Deneyimi Nasıl Sunulur?

HarmonyOS'un en çarpıcı özelliklerinden biri, "süper cihaz" vizyonuyla sunduğu dağıtılmış yeteneklerdir. Bu yetenekler sayesinde, uygulamalar ve veriler farklı cihazlar arasında (telefon, tablet, akıllı saat, akıllı TV vb.) sorunsuz bir şekilde etkileşim kurabilir. Dağıtılmış Preferences (Distributed Preferences), bu dağıtılmış ekosistemin önemli bir parçasıdır ve kullanıcıların kişiselleştirilmiş ayarlarını farklı HarmonyOS cihazları arasında otomatik olarak senkronize etmelerini sağlar. Bu, kullanıcı için tutarlı ve kesintisiz bir deneyim sunmanın anahtarıdır.

Temel Preferences API'sine benzer şekilde, Distributed Preferences da anahtar-değer çiftleri şeklinde veri depolamaya olanak tanır. Ancak en büyük farkı, depolanan verilerin aynı HarmonyOS hesabına bağlı tüm cihazlar arasında otomatik olarak paylaşılması ve senkronize edilmesidir. Bu senkronizasyon, HarmonyOS'un dağıtılmış veri yönetimi mekanizmaları tarafından arka planda halledilir, böylece geliştiriciler karmaşık ağ protokolleri veya veri çakışmalarıyla uğraşmak zorunda kalmazlar.

Dağıtılmış Preferences kullanmak, temel Preferences kullanımına oldukça benzerdir. Normal Preferences'ta preferences.getPreferences() kullanırken, dağıtılmış özellikler için preferences.getDistributedPreferences() metodunu çağırmanız gerekir. Bu metot, dağıtılmış özelliklere sahip bir Preferences örneği döndürür.

import preferences from '@ohos.data.preferences';
import common from '@ohos.app.ability.common';

const DIST_PREFS_FILE_NAME = 'distributed_user_settings';

class DistributedPreferencesService {
    private context: common.AbilityContext;
    private distributedPreferences: preferences.Preferences;

    constructor(context: common.AbilityContext) {
        this.context = context;
    }

    async loadDistributedPreferences(): Promise {
        try {
            this.distributedPreferences = await preferences.getDistributedPreferences(this.context, DIST_PREFS_FILE_NAME);
            console.log('Dağıtılmış Preferences başarıyla yüklendi.');
        } catch (err) {
            console.error(Dağıtılmış Preferences yüklenirken hata oluştu: ${JSON.stringify(err)});
        }
    }

    async saveDistributedSetting(key: string, value: preferences.ValueType): Promise {
        if (!this.distributedPreferences) { console.error('Dağıtılmış Preferences henüz yüklenmedi.'); return; }
        try {
            await this.distributedPreferences.put(key, value);
            await this.distributedPreferences.flush();
            console.log(Dağıtılmış ayar kaydedildi: ${key} -> ${value});
        } catch (err) {
            console.error(Dağıtılmış ayar kaydedilirken hata oluştu: ${JSON.stringify(err)});
        }
    }

    async getDistributedSetting(key: string, defaultValue: preferences.ValueType): Promise {
        if (!this.distributedPreferences) { return defaultValue; }
        try {
            const value = await this.distributedPreferences.get(key, defaultValue);
            console.log(Dağıtılmış ayar okundu: ${key} -> ${value});
            return value;
        } catch (err) {
            console.error(Dağıtılmış ayar okunurken hata oluştu: ${JSON.stringify(err)});
            return defaultValue;
        }
    }

    setupDistributedChangeListener(): void {
        if (!this.distributedPreferences) { console.error('Dağıtılmış Preferences henüz yüklendi.'); return; }
        this.distributedPreferences.onChangeListener((key: string) => {
            console.log(Dağıtılmış Preferences değişti: Anahtar -> ${key});
            this.getDistributedSetting(key, null).then(value => {
                console.log(Değişen anahtar (${key}) için yeni değer: ${value});
            });
        });
    }

    removeDistributedChangeListener(): void {
        if (this.distributedPreferences) {
            this.distributedPreferences.offChangeListener();
            console.log('Dağıtılmış Preferences değişim dinleyicisi kaldırıldı.');
        }
    }
}
/* Ability içinden kullanım örneği
import Ability from '@ohos.app.ability.Ability';
export default class MyDistributedAbility extends Ability {
    private distPreferencesService: DistributedPreferencesService;
    onCreate(want, launchParam) {
        super.onCreate(want, launchParam);
        this.distPreferencesService = new DistributedPreferencesService(this.context);
        this.initDistributedSettings();
    }
    async initDistributedSettings() {
        await this.distPreferencesService.loadDistributedPreferences();
        this.distPreferencesService.setupDistributedChangeListener();
        await this.distPreferencesService.saveDistributedSetting('global_dark_mode', true);
        const isDarkModeGlobal = await this.distPreferencesService.getDistributedSetting('global_dark_mode', false) as boolean;
        console.log(Global Koyu Mod Ayarı: ${isDarkModeGlobal});
    }
    onDestroy() {
        this.distPreferencesService.removeDistributedChangeListener();
        super.onDestroy();
    }
}
*/

Yukarıdaki kodda, DistributedPreferencesService sınıfı, dağıtılmış Preferences'ı yönetmek için tasarlanmıştır. getDistributedPreferences() ile bir örnek alındıktan sonra, put() ve get() metotları normal Preferences ile aynı şekilde kullanılır. Önemli olan nokta, flush() çağrıldığında, veriler sadece yerel olarak kaydedilmekle kalmaz, aynı zamanda HarmonyOS'un dağıtılmış veri senkronizasyon mekanizması tarafından diğer cihazlara da iletilir. Diğer cihazlardaki uygulamalar, aynı DIST_PREFS_FILE_NAME ile tanımlanmış Distributed Preferences dosyasını dinleyerek bu değişikliklerden haberdar olabilir ve kendi UI'larını veya davranışlarını buna göre güncelleyebilirler. onChangeListener, dağıtılmış verideki değişiklikleri de izleyebilir, böylece bir cihazda yapılan bir ayar değişikliği, diğer cihazlarda anında yansıtılabilir. Bu, kullanıcıların bir cihazda ayarladıkları tercihin, kullandıkları tüm HarmonyOS cihazlarında geçerli olmasını sağlayarak gerçekten bağlı ve kişiselleştirilmiş bir ekosistem deneyimi sunar. Dağıtılmış Preferences, özellikle tema ayarları, global bildirim tercihleri veya kullanıcı profili özetleri gibi veriler için mükemmel bir çözümdür.

Performans ve Güvenlik İpuçları: Preferences Kullanırken Nelere Dikkat Etmeliyiz?

HarmonyOS Preferences, küçük ve yapılandırılmamış verilerin depolanması için harika bir araç olsa da, her depolama mekanizması gibi onun da kendine özgü performans ve güvenlik hususları vardır. Uygulamanızın hızlı, güvenilir ve güvenli olduğundan emin olmak için aşağıdaki ipuçlarına dikkat etmek önemlidir.

1. Asenkron İşlemler ve UI Akıcılığı:

Preferences işlemleri (okuma, yazma, silme) disk G/Ç (I/O) operasyonlarıdır. Senkron olarak yapıldığında, özellikle büyük dosyalar veya yoğun işlemler sırasında uygulamanızın ana iş parçacığını (UI thread) bloklayarak arayüzde donmalara neden olabilir. HarmonyOS Preferences API'si zaten Promise tabanlı asenkron metotlar sunduğu için, her zaman async/await yapısını kullanarak bu işlemleri asenkron olarak yürütün. Bu, uygulamanızın UI'ının her zaman akıcı kalmasını sağlar.

async function saveSettingAsync(context: common.AbilityContext, key: string, value: string): Promise {
    try {
        const prefs = await preferences.getPreferences(context, 'my_settings');
        await prefs.put(key, value);
        await prefs.flush();
    } catch (err) {
        console.error(Ayar kaydedilirken hata oluştu: ${JSON.stringify(err)});
    }
}

2. flush() Metodunun Akıllıca Kullanımı:

flush() metodu, bellekteki değişiklikleri diske kalıcı olarak yazılmasını sağlar. Her put() işleminden sonra flush() çağırmak performansı düşürebilir, çünkü her seferinde disk G/Ç işlemi tetiklenir. Birden fazla ayar kaydedecekseniz, tüm put() işlemlerini bitirdikten sonra yalnızca bir kez flush() çağırmak daha verimlidir. HarmonyOS, değişiklikleri belirli aralıklarla otomatik olarak yapsa da, uygulamanızın kapatılma anında veya kritik verilerin hemen kaydedilmesi gerektiğinde flush() kullanmak güvenliği artırır.

await prefs.put('setting1', 'value1');
await prefs.put('setting2', 'value2');
await prefs.flush(); // Sadece bir kez çağrılır

3. Veri Boyut Sınırlamaları:

Preferences, küçük ve basit veriler için tasarlanmıştır. Büyük boyutlu JSON nesneleri, resimler, dosyalar veya çok sayıda anahtar-değer çifti depolamak için uygun değildir. Bu tür veriler için HarmonyOS'un dosya depolama (File I/O), Distributed Data Service veya ObjectStore gibi daha gelişmiş depolama çözümlerini düşünmelisiniz. Preferences'a çok fazla veri depolamak, uygulamanın başlangıç süresini uzatabilir ve okuma/yazma işlemlerini yavaşlatabilir.

4. Güvenlik ve Hassas Veriler:

Preferences tarafından depolanan veriler, cihazın dosya sisteminde genellikle şifrelenmemiş olarak bulunur (root erişimi olan cihazlarda kolayca erişilebilir). Bu nedenle, kullanıcı adları, şifreler, API anahtarları veya finansal bilgiler gibi bilgileri doğrudan Preferences'ta depolamaktan kesinlikle kaçınmalısınız. Hassas veriler için HarmonyOS'un "Security SDK" veya şifreli veritabanları gibi daha güvenli depolama mekanizmaları kullanılmalıdır. Dağıtılmış Preferences kullanırken de aynı güvenlik kuralları geçerlidir; bu veriler cihazlar arasında senkronize edildiği için daha da dikkatli olunmalıdır.

5. Hata Yönetimi:

Disk dolu, dosya erişim izinleri sorunları veya diğer G/Ç hataları gibi durumlar Preferences işlemlerinde beklenmedik hatalara yol açabilir. Tüm Preferences işlemlerini try-catch blokları içine alarak bu hataları düzgün bir şekilde yönetmeli ve kullanıcıya bilgi vermelisiniz. Bu, uygulamanızın kararlılığını artırır.

Bu ipuçlarına dikkat ederek, HarmonyOS Preferences API'sini uygulamanızda etkili, performanslı ve güvenli bir şekilde kullanabilir, kullanıcılarınıza sorunsuz ve kişiselleştirilmiş bir deneyim sunabilirsiniz.

Sonuç: HarmonyOS Preferences ile Kullanıcı Deneyiminizi Nasıl Yükseltirsiniz?

Bu makalede, HarmonyOS geliştiricileri için kullanıcı kişiselleştirilmiş ayarlarını depolamanın temel taşı olan Preferences API'sini derinlemesine inceledik. Kullanıcıların uygulama ile olan bağlarını güçlendiren kişiselleştirmenin önemini vurgulayarak başladık ve Preferences'ın basit anahtar-değer depolama yapısıyla bu ihtiyacı nasıl karşıladığını gösterdik. Temel depolama, okuma ve silme işlemlerini adım adım kod örnekleriyle ele aldık, böylece sıfırdan başlayan bir geliştiricinin bile kolayca uygulayabileceği pratik bilgiler sunduk. Ayrıca, onChangeListener mekanizması sayesinde ayarların dinamik olarak nasıl güncellenebileceğini ve kullanıcı arayüzüne anında nasıl yansıtılabileceğini keşfettik.

HarmonyOS'un benzersiz dağıtılmış yeteneklerinin bir parçası olan Dağıtılmış Preferences ile, kullanıcıların ayarlarını birden fazla cihaz arasında nasıl senkronize edebileceğimizi öğrendik. Bu özellik, modern ve bağlantılı bir ekosistemde kesintisiz bir kullanıcı deneyimi sunmanın kilit noktalarından biridir. Son olarak, Preferences kullanırken dikkat edilmesi gereken performans ve güvenlik ipuçlarını detaylandırdık. Asenkron işlemlerin önemi, flush() metodunun stratejik kullanımı, veri boyut sınırlamaları ve özellikle hassas verilerin depolanmaması gerektiği gibi kritik konulara değindik. Bu ipuçları, uygulamanızın sadece işlevsel değil, aynı zamanda hızlı, güvenilir ve güvenli olmasını sağlamanıza yardımcı olacaktır.

Özetle, HarmonyOS Preferences API'si, kullanıcıların kişiselleştirilmiş tercihlerini ve küçük uygulama ayarlarını yönetmek için güçlü, esnek ve kullanımı kolay bir çözüm sunar. Bu araçtan en iyi şekilde yararlanarak, kullanıcılarınızın beklentilerini aşan, onlara özel hissettiren ve genel uygulama kalitenizi artıran HarmonyOS uygulamaları geliştirebilirsiniz. Unutmayın, kullanıcı deneyiminin anahtarı, uygulamanızı onların parmak uçlarında şekillendirebilme yeteneğidir. Preferences ile bu yeteneği HarmonyOS uygulamalarınıza kazandırın ve fark yaratın!

Sıkça Sorulan Sorular

1. HarmonyOS Preferences mı, yoksa bir veritabanı (örneğin Realm veya ObjectBox) mı kullanmalıyım?

Preferences, basit anahtar-değer çiftleri şeklinde küçük, yapılandırılmamış verileri depolamak için idealdir (örn. tema ayarları, kullanıcı adı). Eğer daha büyük veri kümeleri, ilişkisel veriler, karmaşık sorgulama ihtiyaçları veya güçlü veri tutarlılığı gerekiyorsa, bir veritabanı çözümü (örn. HarmonyOS'un Distributed Data Service'i veya üçüncü taraf çözümler) çok daha uygun olacaktır.

2. Preferences verileri uygulamanın kaldırılmasıyla silinir mi?

Evet, varsayılan olarak Preferences verileri uygulamanın dahili depolama alanında saklandığı için, uygulama cihazdan kaldırıldığında bu veriler de silinir. Bu durum, kişisel ayarların uygulamanın ömrüyle sınırlı kalmasını sağlar.

3. Distributed Preferences kullanmak için özel izinler gerekiyor mu?

Dağıtılmış Preferences kullanmak için manifest dosyanızda ohos.permission.DISTRIBUTED_DATASYNC iznini beyan etmeniz gerekir. Ayrıca, cihazların aynı HarmonyOS hesabıyla oturum açmış olması ve ağ bağlantısının bulunması senkronizasyon için zorunludur.

4. Preferences verilerini farklı uygulamalar arasında paylaşabilir miyim?

Hayır, Preferences verileri uygulama özelindedir ve varsayılan olarak diğer uygulamalar tarafından doğrudan erişilemez. Uygulamalar arası veri paylaşımı için HarmonyOS'un Distributed Data Service, Data Ability veya Common Event Service gibi daha gelişmiş paylaşım mekanizmalarını kullanmanız gerekir.

5. Preferences'a ne kadar veri depolayabilirim? Bir sınırı var mı?

Preferences küçük boyutlu veriler için tasarlanmıştır ve performansı artırmak adına genellikle birkaç yüz KB'ı geçmemesi önerilir. Daha büyük veriler depolandığında, okuma/yazma süreleri artabilir ve uygulama performansı olumsuz etkilenebilir. Her bir dosya için yaklaşık 1-2 MB gibi bir üst limit düşünülebilir, ancak bu, sistem kaynaklarına ve cihaz modeline göre değişebilir.