اکتیویتی ها در اندروید

یک کلاس اکتیویتی یک جز حیاتی از برنامه اندروید است، و اکتیویتی های راه اندازی شده با هم یک بخش اصلی از مدل نرم افزار پلت فرم هستند. بر خلاف مثال های برنامه نویسی که در آن، برنامه ها با متد main() راه اندازی می شوند، سیستم اندروید با استفاده از متد های خاص پاسخ فراخوانی که به مراحل خاص چرخه زندگی خود مربوط می شود، کد را در یک اکتیویتی آغاز می کند

.

این مقاله مفهوم اکتیویتی ها را معرفی می کند و سپس راهنمایی هایی در مورد نحوه کار با آنها می دهد.

مفهوم اکتیویتی ها

کلاس اکتیویتی به عنوان نقطه ورود برای تعامل برنامه با کاربر عمل می کند، و پنجره ای را برای ترسیم UI فراهم می کند. این پنجره به طور معمول صفحه را پر می کند، اما ممکن است از صفحه نمایش کوچکتر، یا در بالای پنجره های دیگر شناور باشد. شما یک اکتیویتی را به عنوان یک زیر کلاس از کلاس اکتیویتی اجرا می کنید. بطور کلی، یک اکتیویتی یک صفحه را در برنامه اجرا می کند به عنوان مثال، یکی از اکتیویتی های برنامه ممکن است روی صفحه Preferences پیاده سازی شود، در صورتیکه اکتیویتی دیگر روی صفحه نمایش پست الکترونیک (Compose Email) پیاده سازی می شود.

اکثر برنامه های دارای چندین صفحه نمایش هستند، به این معنی که اکتیویتی های متعدد را شامل می شوند. به طور معمول، یک اکتیویتی در یک برنامه به عنوان اکتیویتی اصلی (main activity) مشخص می شود، که اولین صفحه ای­ست که هنگام اجرای برنامه کاربر نمایش داده می شود. سپس هر اکتیویتی می تواند اکتیویتی دیگر را برای انجام عملیات مختلف اجرا کند. برای مثال، اکتیویتی اصلی در یک برنامه ایمیل ساده ممکن است صفحه ای را نشان دهد که صندوق ورودی ایمیل را نشان می دهد. در نتیجه، اکتیویتی اصلی ممکن است اکتیویتی های دیگری را ایجاد کند که صفحه هایی را برای کارهایی مانند نوشتن ایمیل و باز کردن ایمیل های فردی آماده کند.

هرچند اکتیویتی ها با هم کار می کنند تا یک تجربه کاربری در یک برنامه ایجاد کند، هر اکتیویتی فقط به اکتیویتی های دیگر محدود می شود؛ معمولاً وابستگی های جزئی بین اکتیویتی ها در یک برنامه وجود دارد. در واقع، اکتیویتی ها اغلب اکتیویتی هایی را که متعلق به برنامه های دیگر هستند را آغاز می کنند. به عنوان مثال، یک برنامه مرورگر ممکن است اکتیویتی Share یک برنامه رسانه اجتماعی را راه اندازی کند.

برای استفاده از اکتیویتی ها در برنامه خود، باید اطلاعات مربوط به آنها را در مانیفست (manifest) برنامه ثبت کنید، و باید چرخه های اکتیویتی برنامه را مدیریت کنید. در نتیجه این سند این موضوعات را معرفی می کند.

پیکربندی مانیفست(manidest)

برای اینکه برنامه شما بتواند از اکتیویتی ها استفاده کند، باید اکتیویتی ها و برخی از ویژگیهای آنها را در مانیفست (manifest) اعلام کنید.


شناساندن اکتیویتی ها

برای اعلام اکتیویتی خود، فایل manifest خود را باز کنید و عنصر <action> را به عنوان یک فرزند از عنصر <application> اضافه کنید. برای مثال:

<manifest ... >
  <application ... >
      <activity android:name=".ExampleActivity" />
      ...
  </application ... >
  ...
</manifest >

تنها ویژگی مورد نیاز برای این عنصر android:name است، که نام کلاس آن اکتیویتی را مشخص می کند. شما همچنین می توانید ویژگی های اکتیویتی را اضافه کنید مانند برچسب، نماد، یا تم UI.



توجه: پس از انتشار برنامه خود، نباید نام اکتیویتی را تغییر دهید. اگر این کار را انجام دهید، ممکن است برخی از قابلیت ها مانند کلید های میانبر برنامه را نقض کنید.

معرفی فیلترهای intent

intent filters (فیلترهای هدفمند) یک ویژگی بسیار قدرتمند از پلت فرم آندروید هستند. آنها توانایی راه اندازی یک اکتیویتی را نه تنها بر اساس یک درخواست صریح، بلکه بصورت ضمنی نیز فراهم می کنند. به عنوان مثال، یک درخواست صریح ممکن است به سیستم "شروع اکتیویتی ارسال ایمیل در برنامه Gmail" را بدهد. در مقابل، یک درخواست ضمنی به سیستم می گوید:"شروع به ارسال یک ایمیل در هر اکتیویتی که می تواند این کار را انجام دهد، می کند" هنگامی که سیستم UI از کاربر می خواهد در برنامه ای که استفاده می­کند، از یک فیلتر intent استفاده کند.


شما می توانید از این ویژگی با تعریف یک <intent-filter> در عنصر <activity> استفاده کنید. تعریف این عنصر شامل یک <action> و عنصر <category> به صورت اختیاری، و / یا عنصر <data> است. این عناصر برای مشخص کردن نوع intent که اکتیویتی شما می تواند پاسخ دهد، ترکیب می شوند. به عنوان مثال، قطعه کد زیر چگونگی پیکربندی یک اکتیویتی که داده های متنی را ارسال می کند و درخواست هایی از اکتیویتی های دیگر را برای انجام این کار دریافت می کند را نشان می­دهد:

  <activity android:name=".ExampleActivity" android:icon="@drawable/app_icon">
    <intent-filter>
        <action android:name="android.intent.action.SEND" />
        <category android:name="android.intent.category.DEFAULT" />
        <data android:mimeType="text/plain" />
    </intent-filter>
<activity>

در این مثال، عنصر <action> مشخص می کند که این اکتیویتی داده ها را ارسال می کند. اعلان عنصر <category> به عنوان DEFAULT (پیش فرض) این اکتیویتی را قادر می سازد تا درخواست ها را دریافت کند. عنصر <data> نوع داده هایی را که این اکتیویتی می تواند ارسال کند مشخص می کند. قطعه کد زیر چگونگی کار با اکتیویتی های شرح داده شده در بالا را نشان می­دهد:

// Create the text message with a string
Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, textMessage);
sendIntent.setType("text/plain");
// Start the activity
startActivity(sendIntent);

اگر می خواهید برنامه شما محتوا داشته باشد و به دیگر برنامه ها اجازه دسترسی به اکتیویتی های خود را ندهید شما به هیچ فیلتر initent دیگری نیاز ندارید. اکتیویتی هایی که نمی خواهید توسط برنامه های دیگر در دسترس قرار گیرند، نباید فاکتورهای intent داشته باشند، و شما می توانید خودتان با استفاده از مفاهیم صریح آن را شروع کنید.

تعریف مجوز (permissions)

شما می توانید از برچسب <activity> در مانیفست برای کنترل برنامه هایی که می توانید یک اکتیویتی خاص را شروع کنید استفاده کنید. اکتیویتی پدر نمی تواند اکتیویتی فرزند را راه اندازی کند، مگر اینکه هر دو اکتیویتی مجوز مشابه در manifest داشته باشند. اگر یک عنصر <uses-permission> را برای یک اکتیویتی خاص اعلام کنید، اکتیویتی صدا زده باید با <use-permission> تطابق داشته باشد.

به عنوان مثال، اگر برنامه شما می خواهد از یک برنامه فرضی به نام SocialApp برای اشتراک گذاری در رسانه های اجتماعی استفاده کند، خود SocialApp باید مجوزی را که برنامه ای را فراخوانی کند داشته باشد. باید تعریف کنید:

<manifest>
<activity android:name="...."
   android:permission=”com.google.socialapp.permission.SHARE_POST”

/>

سپس اجازه می­دهد که SocialApp را صدا بزنید، برنامه شما باید با مجوز SocialApp در manifest مطابقت کند:

<manifest>
   <uses-permission android:name="com.google.socialapp.permission.SHARE_POST" />
</manifest>


مدیریت چرخه حیات اکتیویتی

در دوره حیات، اکتیویتی در تعدادی از حالت ها انجام می شود. شما از یک سری از فراخوانی ها برای مدیریت انتقال بین حالت­ ها استفاده می کنید. بخش های زیر این فراخوانی ها را معرفی می کنند.

onCreate ()

شما باید این فراخوانی را اجرا کنید، که هنگام فعال شدن یک اکتیویتی ایجاد می شود. اجرای شما باید اجزای ضروری اکتیویتی خود را راه اندازی کند: به عنوان مثال، برنامه شما باید view ها را ایجاد کند و داده ها را به لیست ها متصل کند. مهمتر از همه، این جایی است که شما باید setContentView () را برای تعریف لایوت برای رابط کاربری فعال کنید.
هنگامی که onCreate () پایان می یابد، فراخوانی بعدی همیشه onStart () آغاز می شود.

on start ()

به عنوان خروجی onCreate ()، اکتیویتی وارد حالت شروع می شود و اکتیویتی برای کاربر قابل مشاهده است. این فراخوان شامل مقادیری از آمادگی نهایی اکتیویتی برای ورود به پیش زمینه و تبدیل شدن به محیط تعاملی است.

OnResume()

سیستم فراخوان این تماس را درست قبل از شروع اکتیویتی با کاربر برقرار می کند. در این مرحله، اکتیویتی در بالای پشته اکتیویتی است و تمام ورودی های کاربر را ضبط می کند. اکثر قابلیت های اصلی برنامه در روش onResume () اجرا می شود.

فراخوان onPause () همیشه در onResume () دنبال می شود.

onPause ()

سیستم هنگامی که اکتیویتی تمرکز را از دست می دهد و در حالت onPause() متوقف می شود. این حالت زمانی اتفاق می افتد که، برای مثال، کاربر دکمه Back یا Overlay را لمس می کند. هنگامی که سیستم بر پایه onPause() برای اکتیویتی خود فراخوانی می شود، به طور فنی به این معنی است که اکتیویتی شما هنوز هم آرام و پیدا است اما اغلب نشان می دهد که کاربر می­ خواهد اکتیویتی را ترک کند و اکتیویتی به زودی به وضعیت متوقف (stop) یا ادامه یافتن (Resume) وارد می شود.

یک اکتیویتی در حالت متوقف شده ممکن است همچنان بروز رسانی را ادامه دهد اگر UI کاربر منتظر بروز رسانی UI باشد. نمونه هایی از چنین اکتیویتی هایی شامل نمایش یک صفحه نقشه ناوبری یا بازی پخش رسانه ای می باشد. حتی اگر چنین اکتیویتی هایی تمرکز را از دست بدهند، کاربر انتظار دارد UI به بروز رسانی خود ادامه دهد.

شما نباید در onPause() برای ذخیره کاربرد یا داده های کاربر، برقراری تماس های شبکه یا انجام معاملات پایگاه داده استفاده کنید.

هنگامی که onPause () اجرا می شود، فراخوان بعدی یا onStop () یا onResume () بسته به آنچه اتفاق می افتد اجرا می ­شود پس از آن اکتیویتی وارد حالت توقف (pause) شده است.

onStop ()

هنگامی که اکتیویتی دیگر برای کاربر قابل مشاهده نیست، onStop() صدا شده است. این ممکن است زمانی اتفاق بیفتد که اکتیویتی تخریب شده و یک اکتیویتی جدید شروع شده است، یا یک اکتیویتی فعلی در حال وارد شدن به حالت Resume است و اکتیویتی Stop را پوشش می دهد. در تمام این موارد اکتیویتی متوقف شده دیگر قابل مشاهده نیست.
فراخوانی بعدی که سیستم صدا می­ زند، یا onRestart ()، اگر اکتیویتی دوباره با کاربر ارتباط برقرار کند، و یا onDestroy ()، اگر این اکتیویتی به طور کامل متوقف شود، می باشد.

onRestart ()

سیستم هنگام فراخوانی اکتیویتی در وضعیت متوقف شده، onRestart()را فراخوانی می کند. این حالت اکتیویتی را از زمانی که متوقف شد بازیابی می کند.
این فراخوانی همیشه توسط onStart () دنبال می شود.

onDestroy ()

سیستم این فراخوانی را قبل از اکتیویتی نابود می کند.

این آخرین فراخوانی است که اکتیویتی دریافت می کند. onDestroy ()معمولاً اجرا می شود تا اطمینان حاصل شود که تمام منابع یک اکتیویتی رها شده وقتی که اکتیویتی یا فرآیند حاوی آن تخریب شود.

این بخش فقط مقدمه ای بر این موضوع بود.

دیدگاه‌ها   

0 #1 علی زمانی ها 1396-08-10 12:40
سلام، تا اینجا تمام مطالبتون رو مطالعه کردم و بابت زحماتتون بسیار متشکرم. سوالی که داشتم اینه که تا اتمام آموزش ها چند فصل دیگه مونده؟ به عبارتی ما چند درصد از مهارتای ایجاد یک برنامه ی اندروید رو یاد گرفتیم؟
نقل قول کردن

نوشتن دیدگاه


تصویر امنیتی
تصویر امنیتی جدید

جوملا فارسی