البيانات المباشرة نظره عامه

الإعلانات

البيانات المباشرة

 

 

نظرة عامة على البيانات المباشرة

البيانات المباشرة LiveData هي فئة تحمل بيانات يمكن ملاحظتها. على عكس الملحوظات الإعتياديه، فإن البيانات المباشرة مدركة لدورة الحياة..

مما يعني إنها تراعي دورة حياة، مكونات التطبيق الأخرى، مثل الأنشطة أو الشظايا أو الخدمات.

يضمن هذا الإدراك، أن تقوم البيانات المباشرة، فقط بتحديث مراقبي مكونات التطبيق، الذين يكونون في حالة دورة حياة النشاط.

ملاحظة: لإستيراد مكونات البيانات المباشرة LiveData إلى مشروع الأندرويد، راجع إضافة مكونات إلى مشروعك.

تعتبر البيانات المباشرة مراقباً، وتمثلها فئة المراقبه، لتكون في الحالة النشطة، إذا كانت دورة حياتها في حالة البدء STARTED أو الإستئناف RESUMED.

تقوم البيانات المباشرة فقط، بإعلام المراقبين النشطين عن التحديثات. المراقبين غير النشطين المسجلين لمراقبة، كائنات البيانات المباشرة لا يتم إعلامها بالتغييرات.

يمكنك تسجيل مراقب مقترن، مع كائن يقوم بتنفيذ واجهة LifecycleOwner. تسمح هذه العلاقة بإزالة المراقب، عندما تتغير حالة كائن دورة الحياة..

المطابقة إلى حالة التدمير DESTROYED. هذا مفيد بشكلٍ خاص للأنشطة والشظايا لأنها تستطيع مراقبة كائنات البيانات المباشرة بأمان..

وعدم القلق بشأن التسريبات – يتم إلغاء الأنشطة والشظايا على الفور، عند تدمير دورات حياتها.

لمزيد من المعلومات حول كيفية إستخدام البيانات المباشرة، راجع العمل مع كائنات البيانات المباشرة.

 

 

مزايا إستخدام البيانات المباشرة

 

يوفر إستخدام البيانات المباشرة المزايا التالية:

 

تأكد أن واجهة المستخدم الخاصة بك تتطابق مع حالة البيانات

البيانات المباشرة تتبع نمط المراقبه. تقوم البيانات المباشرة بإعلام كائنات المراقبه عندما تتغير حالة دورة الحياة.

يمكنك دعم كودك، لتحديث واجهة المستخدم، في كائنات المراقبه Observer هذه. بدلاً من تحديث واجهة المستخدم..

في كل مرة تتغير فيها بيانات التطبيق، يمكن للمراقب تحديث واجهة المستخدم، في كل مرة يحدث فيها تغيير.

 

لا تسرب في الذاكرة

يرتبط المراقبون بكائنات دورة الحياة، ويقوموا بتنظيف أنفسهم، بعد أن يتم تدمير دورة حياتهم المقترنه.

 

لا تعطل بسبب توقف الأنشطة

إذا كانت دورة حياة المراقب غير نشطة، كما هو الحال في حالة كون النشاط في الكومة الخلفية، فلن يتلقى أي أحداث للبيانات المباشرة.

 

لا مزيد من التعامل مع دورة الحياة يدوياً

مكونات واجهة المستخدم، تراقب فقط البيانات ذات الصلة، ولا تقوم بإيقاف أو إستئناف المراقبة.

تدير البيانات المباشرة، كل هذا تلقائياً، حيث إنها مدركة لتغييرات حالة دورة الحياة ذات الصلة، أثناء المراقبة.

 

تحديث البيانات دائماً

إذا أصبحت دورة الحياة غير نشطة، فسوف تستقبل أحدث البيانات بعد أن تصبح نشطة مرة أخرى.

مثال، يتلقى النشاط الذي كان في الخلفية، أحدث البيانات مباشرة، بعد إرجاعه إلى المقدمة.

 

تغييرات التكوين الملائمه

إذا تم إعادة إنشاء نشاط أو شظيه، بسبب حدوث تغير في التكوين، مثل تدوير الجهاز، فسوف يتلقى أحدث البيانات المتاحة فوراً.

 

مشاركة المصادر

يمكنك توسيع كائن البيانات المباشرة LiveData بإستخدام النمط المفرد، لإحتواء خدمات النظام، بحيث يمكن مشاركتها في تطبيقك.

يتصل كائن البيانات المباشرة بخدمة النظام مرة واحدة، ومن ثم يمكن لأي مراقب، يحتاج إلى المصدر، مراقبة كائن البيانات المباشرة فقط.

لمزيد من المعلومات، راجع توسيع البيانات المباشرة.

 

 

التعامل مع كائنات البيانات المباشرة


أتبع هذه الخطوات للتعامل مع كائنات البيانات المباشرة:

1- قم بإنشاء مثيل للبيانات المباشرة، يستوعب نوع معين من البيانات. يتم ذلك عادةً داخل فئة ViewModel.

2- قم بإنشاء كائن مراقبة Observer الذي يعرّف دالة ()onChanged، التي تتحكم فيما يحدث عندما تتغير البيانات، التي يستوعبها كائن البيانات المباشرة.

عادة ما تقوم بإنشاء كائن مراقبة، في وحدة تحكم واجهة المستخدم، مثل النشاط أو الشظيه.

3- قم بإرفاق كائن المراقبه إلى كائن البيانات المباشرة، بإستخدام دالة المراقبه ()observe .

تأخذ دالة المراقبة ()observe كائن “مالك دورة الحياة” LifecycleOwner. هذا يشرك كائن المراقبه Observer ..

مع كائن البيانات المباشرة LiveData بحيث يتم إشعاره بالتغييرات. عادة ما تقوم بتوصيل كائن المراقبة بوحدة تحكم واجهة المستخدم، مثل النشاط أو الشظيه.

ملاحظة: يمكنك تسجيل مراقب بدون وجود كائن “مالك دورة الحياة” LifecycleOwner مقترن، بإستخدام دالة (observeForever (Observer.

في هذه الحالة، يعتبر المراقب نشط دائماً ولذلك يتم إخبارك دائماً بالتعديلات. يمكنك إزالة هؤلاء المراقبين بإستدعاء الداله (removeObserver (Observer.

عندما تقوم بتحديث القيمة المخزنة، في كائن البيانات المباشرة، فإنه يقوم بتشغيل كافة المراقبين المسجلين، طالما أن LifecycleOwner المرفقه في حالة نشطة.

تسمح البيانات المباشرة، لمراقبي وحدة تحكم واجهة المستخدم بالإشتراك في التحديثات.

عندما تتغير البيانات الموجودة في كائن البيانات المباشرة، يتم تحديث واجهة المستخدم تلقائياً إستجابةً لذلك.

 

 

 

إنشاء كائنات البيانات المباشرة


البيانات المباشرة عبارة عن غطاء يمكن إستخدامه مع أي بيانات، بما في ذلك الكائنات التي تقوم بتنفيذ المجموعات، مثل القائمة.

عادة ما يتم تخزين كائن البيانات المباشرة بداخل كائن ViewModel ويتم الوصول إليه عبر دالة الجلب getter، كما هو موضح في المثال التالي:

KOTLIN

class NameViewModel : ViewModel() {

    // Create a LiveData with a String
    val currentName: MutableLiveData<String> by lazy {
        MutableLiveData<String>()
    }

    // Rest of the ViewModel...
}

JAVA

public class NameViewModel extends ViewModel {

// Create a LiveData with a String
private MutableLiveData<String> mCurrentName;

    public MutableLiveData<String> getCurrentName() {
        if (mCurrentName == null) {
            mCurrentName = new MutableLiveData<String>();
        }
        return mCurrentName;
    }

// Rest of the ViewModel...
}

 

بدايةً، لم يتم تعيين البيانات في كائن البيانات المباشرة LiveData.

ملاحظة: تأكد من تخزين كائنات البيانات المباشرة التي تقوم بتحديث واجهة المستخدم في كائنات ViewModel، بدلاً من النشاط أو الشظيه، للأسباب التالية:

– لتجنب تضخم الأنشطة والشظايا. والآن أصبحت وحدات التحكم في واجهة المستخدم هذه، مسؤولة عن عرض البيانات وليس حمل حالة البيانات.

– لفصل مثيلات البيانات المباشرة عن مثيلات نشاط أو شظية معينه وتسمح لكائنات البيانات المباشرة أن تسلم من تغييرات التكوين.

يمكنك قراءة المزيد حول فوائد وإستخدام فئة ViewModel في دليل ViewModel.

 

 

 

مراقبة كائنات البيانات المباشرة


في معظم الحالات، تكون دالة ()onCreate لمكون التطبيق هي المكان المناسب لبدء مراقبة كائن البيانات المباشرة LiveData للأسباب التالية:

– لضمان عدم قيام النظام، بإجراء إستدعاءات زائدة من دالة ()onResume لنشاط أو شظية ما.

– للتأكد من أن النشاط أو الشظيه، تحتوي على بيانات يمكن عرضها، بمجرد أن يصبح النشاط أو الشظية نشطاً.

بمجرد أن يكون أحد مكونات التطبيق، في حالة البدء STARTED، فسوف يتلقى أحدث قيمة من كائنات البيانات المباشرة التي يراقبها.

يحدث هذا فقط، إذا تم تعيين كائن البيانات المباشرة، المراد مراقبته.

بشكلٍ عام، توفر البيانات المباشرة التحديثات فقط عند تغير البيانات، وفقط للمراقبين النشطين.

الإستثناء من هذا السلوك هو، أن المراقبين يتلقون تحديث أيضاً، عندما يتغيرون من الحالة الغير نشطه إلى الحالة النشطة.

علاوة على ذلك، إذا تغير المراقب من الحالة الغير نشطة، إلى الحالة النشطة مرة ثانية، فإنه يتلقى تحديث فقط، إذا تغيرت القيمة منذ آخر مرة أصبح فيها نشطاً.

 

يوضح نموذج الكود التالي كيفية بدء مراقبة كائن البيانات المباشرة LiveData:

KOTLIN

class NameActivity : AppCompatActivity() {

    private lateinit var mModel: NameViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Other code to setup the activity...

        // Get the ViewModel.
        mModel = ViewModelProviders.of(this).get(NameViewModel::class.java)


        // Create the observer which updates the UI.
        val nameObserver = Observer<String> { newName ->
            // Update the UI, in this case, a TextView.
            mNameTextView.text = newName
        }

        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
        mModel.currentName.observe(this, nameObserver)
    }
}

JAVA

public class NameActivity extends AppCompatActivity {

    private NameViewModel mModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Other code to setup the activity...

        // Get the ViewModel.
        mModel = ViewModelProviders.of(this).get(NameViewModel.class);


        // Create the observer which updates the UI.
        final Observer<String> nameObserver = new Observer<String>() {
            @Override
            public void onChanged(@Nullable final String newName) {
                // Update the UI, in this case, a TextView.
                mNameTextView.setText(newName);
            }
        };

        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
        mModel.getCurrentName().observe(this, nameObserver);
    }
}

 

بعد إستدعاء دالة المراقبة ()observe مع تمرير nameObserver كمعامل، يتم إستدعاء ()onChanged مباشرة موفرة أحدث قيمة مخزنة في mCurrentName.

إذا لم يقم كائن البيانات المباشرة بتعيين قيمة في mCurrentName، لا يتم إستدعاء ()onChanged.

 

 

 

تحديث كائنات البيانات المباشرة


ليس لدى البيانات المباشرة، أية دوال متوفرة بشكلٍ عام، لتحديث البيانات المخزنة. فئة MutableLiveData تكشف بشكلٍ عام..

عن دوال (setValue(T و (postValue(T ويجب عليك، إستخدام هذه إذا كنت بحاجة إلى تحرير القيمة المخزنة، في كائن البيانات المباشرة.

عادة ما يتم إستخدام MutableLiveData في ViewModel ثم تقوم ViewModel فقط بكشف كائنات LiveData غير القابلة للتغيير إلى المراقبين.

بعد قيامك بإعداد علاقة المراقب، يمكنك عندئذ تحديث قيمة كائن البيانات المباشرة، كما هو موضح في المثال التالي..

والذي يقوم بتشغيل كل المراقبين، عند قيام المستخدم بالنقر فوق زر:

KOTLIN

mButton.setOnClickListener {
    val anotherName = "John Doe"
    mModel.currentName.setValue(anotherName)
}

JAVA

mButton.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        String anotherName = "John Doe";
        mModel.getCurrentName().setValue(anotherName);
    }
});

 

إستدعاء (setValue(T في المثال تؤدي إلى قيام المراقب بإستدعاء دوال ()onChanged الخاصة به مع قيمة مجهوله John Doe.

يعرض المثال ضغطة زر، ولكن يمكن إستدعاء ()setValue أو ()postValue لتحديث mName لعدة أسباب..

بما في ذلك إستجابة لطلب الشبكة، أو إستكمال تحميل قاعدة البيانات؛ في جميع الحالات، يؤدي إستدعاء..

 ()setValue أو ()postValue إلى تشغيل المراقبين وتحديث واجهة المستخدم.

ملاحظة: يجب إستدعاء الدالة (setValue(T لتحديث كائن البيانات المباشره من التسلسل الرئيسي. إذا تم تنفيذ الكود في التسلسل العامل..

يمكنك إستخدام دالة (postValue (T بدلاً من تحديث كائن البيانات المباشره.

 

 

 

إستخدام البيانات المباشرة مع الروم


تدعم مكتبة ثبات الروم الإستعلامات القابلة للمراقبة، والتي تقوم بإرجاع كائنات البيانات المباشره.

تتم كتابة الإستعلامات القابلة للمراقبة، كجزء من كائن الوصول إلى قاعدة البيانات (DAO).

يقوم الروم بإنشاء كافة الأكواد اللازمة، لتحديث كائن البيانات المباشره، عند تحديث قاعدة البيانات.

تقوم الأكواد التي تم إنشاؤها، بتشغيل الإستعلام بشكلٍ غير متزامن، على تسلسل الخلفية عند الحاجة.

هذا النمط مفيد، للحفاظ على البيانات المعروضة، في واجهة المستخدم، متزامنة مع البيانات المخزنة في قاعدة البيانات.

يمكنك قراءة المزيد عن الروم و DAOs في دليل مكتبة ثبات الروم.

 

 

 

 

توسيع البيانات المباشره


تعتبر البيانات المباشره كمراقب في حالة نشطة، إذا كانت دورة حياة المراقب، إما في حالة البدء STARTED أو حالة الإستئناف RESUMED ..

يوضح نموذج الكود التالي كيفية توسيع فئة البيانات المباشره:

KOTLIN

class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
    private val mStockManager = StockManager(symbol)

    private val mListener = { price: BigDecimal ->
        value = price
    }

    override fun onActive() {
        mStockManager.requestPriceUpdates(mListener)
    }

    override fun onInactive() {
        mStockManager.removeUpdates(mListener)
    }
}

JAVA

public class StockLiveData extends LiveData<BigDecimal> {
    private StockManager mStockManager;

    private SimplePriceListener mListener = new SimplePriceListener() {
        @Override
        public void onPriceChanged(BigDecimal price) {
            setValue(price);
        }
    };

    public StockLiveData(String symbol) {
        mStockManager = new StockManager(symbol);
    }

    @Override
    protected void onActive() {
        mStockManager.requestPriceUpdates(mListener);
    }

    @Override
    protected void onInactive() {
        mStockManager.removeUpdates(mListener);
    }
}

 

يتضمن تطبيق مستمع الأسعار في هذا المثال على الدوال الهامه التالية:

  • يتم إستدعاء دالة ()onActive عندما يكون لدى كائن البيانات المباشره مراقب نشط.

و هذا يعني أنك بحاجة إلى البدء في مراقبة تحديثات أسعار الأسهم من هذه الدالة.

 

  • يتم إستدعاء دالة ()onInactive عندما لا يكون لدى كائن البيانات المباشره أي مراقبين نشطين.

بما أنه لا يوجد مراقبين يستمعون، فلا يوجد سبب للبقاء على إتصال بخدمة StockManager.

 

  • تقوم دالة (setValue (T بتحديث قيمة مثيل البيانات المباشره وإعلام أي مراقبين نشطين عن التغيير.

 

يمكنك إستخدام فئة StockLiveData كما يلي:

KOTLIN

override fun onActivityCreated(savedInstanceState: Bundle?) {
    super.onActivityCreated(savedInstanceState)
    val myPriceListener: LiveData<BigDecimal> = ...
    myPriceListener.observe(this, Observer<BigDecimal> { price: BigDecimal? ->
        // Update the UI.
    })
}

JAVA

public class MyFragment extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        LiveData<BigDecimal> myPriceListener = ...;
        myPriceListener.observe(this, price -> {
            // Update the UI.
        });
    }
}

 

تقوم دالة المراقبة ()observe بتمرير الشظيه، والتي هي مثيل لـ LifecycleOwner، كالمعامل الأول.

يشير هذا إلى أن هذا المراقب، مرتبط بكائن دورة الحياة، المرتبطه بالمالك، وهو ما يعني:

  •  إذا لم يكن كائن دورة الحياة، في الحالة النشطة، فلن يتم إستدعاء المراقب حتى لو تغيرت القيمة.

 

  • بعد تدمير كائن دورة الحياة، تتم إزالة المراقب تلقائياً.

 

تعني حقيقة أن كائنات “البيانات المباشره”، مدركة لدورة الحياة، أنه يمكنك مشاركتها بين العديد من الأنشطة، الشظايا، والخدمات.

للحفاظ على المثال بسيطاً، يمكنك تنفيذ فئة البيانات المباشره على النحو المفرد كما يلي:

KOTLIN

class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
    private val mStockManager: StockManager = StockManager(symbol)

    private val mListener = { price: BigDecimal ->
        value = price
    }

    override fun onActive() {
        mStockManager.requestPriceUpdates(mListener)
    }

    override fun onInactive() {
        mStockManager.removeUpdates(mListener)
    }

    companion object {
        private lateinit var sInstance: StockLiveData

        @MainThread
        fun get(symbol: String): StockLiveData {
            sInstance = if (::sInstance.isInitialized) sInstance else StockLiveData(symbol)
            return sInstance
        }
    }
}

JAVA

public class StockLiveData extends LiveData<BigDecimal> {
    private static StockLiveData sInstance;
    private StockManager mStockManager;

    private SimplePriceListener mListener = new SimplePriceListener() {
        @Override
        public void onPriceChanged(BigDecimal price) {
            setValue(price);
        }
    };

    @MainThread
    public static StockLiveData get(String symbol) {
        if (sInstance == null) {
            sInstance = new StockLiveData(symbol);
        }
        return sInstance;
    }

    private StockLiveData(String symbol) {
        mStockManager = new StockManager(symbol);
    }

    @Override
    protected void onActive() {
        mStockManager.requestPriceUpdates(mListener);
    }

    @Override
    protected void onInactive() {
        mStockManager.removeUpdates(mListener);
    }
}

ويمكنك إستخدامه في الشظية على النحو التالي:

KOTLIN

class MyFragment : Fragment() {

    override fun onActivityCreated(savedInstanceState: Bundle?) {
        StockLiveData.get(symbol).observe(this, Observer<BigDecimal> { price: BigDecimal? ->
            // Update the UI.
        })

    }

JAVA

public class MyFragment extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        StockLiveData.get(symbol).observe(this, price -> {
            // Update the UI.
        });
    }
}

 

العديد من الشظايا والأنشطة، يمكنها مراقبة مثيل MyPriceListener. تتصل البيانات المباشرة فقط، بخدمة النظام، إذا كان واحد منهم أو أكثر مرئياً ونشطاً.

 

 

 

تحويل البيانات المباشرة


قد ترغب في إجراء تغييرات، على القيمة المخزنة، في كائن البيانات المباشره ، قبل إرسالها إلى المراقبين..

أو قد تحتاج إلى، إرجاع مثيل بيانات مباشرة مختلف، بناءً على قيمة كائن آخر. توفر حزمة دورة الحياة فئة التحويل..

 Transformations التي تتضمن دوال مساعده، تدعم هذه السيناريوهات.

 

()Transformations.map

يقوم بتطبيق وظيفة على القيمة المخزنة في كائن البيانات المباشره، ثم ينشر النتيجة النهائية.

KOTLIN

val userLiveData: LiveData<User> = UserLiveData()
val userName: LiveData<String> = Transformations.map(userLiveData) {
    user -> "${user.name} ${user.lastName}"
}

JAVA

LiveData<User> userLiveData = ...;
LiveData<String> userName = Transformations.map(userLiveData, user -> {
    user.name + " " + user.lastName
});

 

()Transformations.switchMap

بشكلٍ مشابه لـ()map، يقوم بتطبيق وظيفة على القيمة المخزنة في كائن البيانات المباشره ثم يقوم بفك وإرسال النتيجة النهائيه.

الوظيفة التي تم تمريرها إلى ()switchMap يجب أن تقوم بإرجاع كائن البيانات المباشره، كما هو موضح في المثال التالي:

KOTLIN

private fun getUser(id: String): LiveData<User> {
  ...
}
val userId: LiveData<String> = ...
val user = Transformations.switchMap(userId) { id -> getUser(id) }

JAVA

private LiveData<User> getUser(String id) {
  ...;
}

LiveData<String> userId = ...;
LiveData<User> user = Transformations.switchMap(userId, id -> getUser(id) );

 

يمكنك إستخدام دوال التحويل، لنقل المعلومات عبر دورة حياة المراقب. لا يتم حساب التحويلات إلا إذا كان أحد المراقبين..

يقوم بمراقبة كائن البيانات المباشره الذي تم إرجاعه. لأن التحولات يتم حسابها ببطء، يتم تمرير السلوك المرتبط بدورة الحياة..

بشكلٍ ضمني دون الحاجة إلى إستدعاءات أو تبعيات صريحة إضافية.

إذا كنت تعتقد أنك بحاجة إلى كائن دورة حياة، بداخل كائن ViewModel، فربما يكون التحويل حلاً أفضل.

مثال، أفترض أن لديك مكون واجهة مستخدم، يقبل عنوان، ثم يقوم بإرجاع الرمز البريدي، لذلك العنوان.

يمكنك تنفيذ ViewModel البسيط، لهذا المكون كما هو موضح بواسطة نموذج الكود التالي:

KOTLIN

class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() {

    private fun getPostalCode(address: String): LiveData<String> {
        // DON'T DO THIS
        return repository.getPostCode(address)
    }
}

JAVA

class MyViewModel extends ViewModel {
    private final PostalCodeRepository repository;
    public MyViewModel(PostalCodeRepository repository) {
       this.repository = repository;
    }

    private LiveData<String> getPostalCode(String address) {
       // DON'T DO THIS
       return repository.getPostCode(address);
    }
}

 

ثم يحتاج مكون واجهة المستخدم، إلى إلغاء تسجيل من كائن البيانات المباشره السابق، ومن ثم التسجيل إلى المثيل الجديد..

في كل مرة يتم إستدعاء ()getPostalCode. بالإضافة إلى ذلك، إذا تم إعادة إنشاء مكون واجهة المستخدم..

فسيؤدي ذلك إلى تشغيل إستدعاء آخر لدالة ()repository.getPostCode بدلاً من إستخدام نتيجة الإستدعاء السابق.

بدلاً من ذلك، يمكنك تنفيذ البحث عن الرمز البريدي، كتحويل لإدخال العنوان، كما هو موضح في المثال التالي:

KOTLIN

JAVA

class MyViewModel extends ViewModel {
    private final PostalCodeRepository repository;
    private final MutableLiveData<String> addressInput = new MutableLiveData();
    public final LiveData<String> postalCode =
            Transformations.switchMap(addressInput, (address) -> {
                return repository.getPostCode(address);
             });

  public MyViewModel(PostalCodeRepository repository) {
      this.repository = repository
  }

  private void setInput(String address) {
      addressInput.setValue(address);
  }
}

 

في هذه الحالة، يكون حقل الرمز البريدي postalCode عام ونهائي، لأن الحقل لا يتغير أبداً.

يتم تعريف حقل الرمز البريدي، كتحويل لإدخال العنوان addressInput، مما يعني أنه يتم إستدعاء دالة ()repository.getPostCode ..

عند تغيير إدخال العنوان addressInput. يكون هذا صحيح إذا كان هناك مراقب نشط، إذا لم يكن هناك مراقب نشط..

في الوقت الذي يتم فيه إستدعاء ()repository.getPostCode ، لا يتم إجراء أي حسابات حتى تتم إضافة مراقب.

هذه الآلية تسمح للمستويات الأقل من التطبيق، بإنشاء كائنات بيانات مباشرة، و التي يتم حسابها بسهولة عند الطلب.

يمكن لعنصر ViewModel الحصول بسهولة، على مراجع لكائنات البيانات المباشره، ومن ثم تحديد قواعد التحويل فوقهم.

 

 

 

إنشاء تحولات جديدة


هناك العشرات من مختلف عمليات التحويل المحددة، والتي قد تكون مفيدة في تطبيقك، ولكن لا يتم تقديمها بشكلٍ إفتراضي.

لتنفيذ التحويل الخاص بك، يمكنك إستخدام فئة MediatorLiveData، التي تستمع إلى كائنات البيانات المباشره الأخرى، وعمليات الأحداث المنبعثه منها.

تقوم MediatorLiveData بنشر حالتها بشكلٍ صحيح، إلى مصدر كائن البيانات المباشره.

لمعرفة المزيد حول هذا النمط، راجع الوثائق المرجعية لفئة التحويل Transformations.

 

 

 

دمج عدة مصادر للبيانات المباشرة


MediatorLiveData هي فئة فرعية من البيانات المباشره، تسمح لك بدمج عدة مصادر للبيانات المباشرة.

ومن ثم يتم تشغيل مراقبي كائنات MediatorLiveData عند تغيير أي من، كائنات مصدر البيانات المباشره الأصلي.

مثال، إذا كان لديك كائن بيانات مباشرة، في واجهة المستخدم، والذي يمكن تحديثه من قاعدة بيانات محلية، أو من شبكة، فيمكنك إضافة المصادر التالية إلى كائن MediatorLiveData:

  •  كائن بيانات مباشرة مقترن بالبيانات المخزنة في قاعدة البيانات.
  •  كائن بيانات مباشرة مقترن بالبيانات التي تم الوصول إليها من الشبكة.

يحتاج نشاطك فقط، إلى مراقبة كائن MediatorLiveData لتلقي التحديثات من كلا المصدرين.

للحصول على مثال تفصيلي، راجع الإضافة: كشف قسم حالة الشبكة من الدليل إلى بنية التطبيق.

 

 

 

مصادر إضافية


تستخدم البيانات المباشره في تطبيق Sunflower التجريبي.

راجع أيضاً النموذج الأساسي لمحتويات البنيه.

للحصول على معلومات إضافية، حول إستخدام البيانات المباشره مع رسائل Snackbar ، وأحداث التنقل، والأحداث الأخرى، اقرأ هذه المشاركة.

 


للإطلاع على المقال باللغة الإنجليزية أضغط هنا.

الإعلانات