آموزش برنامه نویسی

اکتیویتی اندروید چیست؟ چگونه اکتیویتی اندروید بسازیم؟

اکتیویتی اندروید چیست؟ چگونه اکتیویتی اندروید بسازیم؟

اکتیویتی اندروید چیست؟ چگونه اکتیویتی بسازیم؟

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

این مقاله دارای قسمت های زیر است:

  • مفهوم اکتیویتی ها
  • یک مقدار فنی تر، اکتیویتی دقیقا چیست؟
  • ساختار اکتیویتی
  • چرخه عمر اکتیویتی
  • متدهای چرخه عمر اکتیویتی
    متد onCreate
    متد onStart
    متد onResume
    متد onPause
    متد onStop
    متد onRestart
    متد onDestroy
  • جمع بندی متدهای چرخه عمر
  • حلقه های کلیدی در چرخه عمر اکتیویتی
  • چگونه در اندروید استودیو اکتیویتی بسازیم؟
    روش اول – ساخت اکتیویتی در ابتدای پروژه
    روش دوم – Add کردن اکتیویتی
    روش سوم – ساخت کلاس و لایوت دستی
  • تنظیمات Manifest
    تعریف Intent Filter برای Activity
  • Intent چیست؟
  • آشنایی با Intent Filter ها
  • تعریف کردن Permission ها برای Activity
  • جمع بندی
  • سوالی دارید؟
  • منابع بیشتر برای مطالعه

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

اکتیویتی ها از مهمترین کامپوننت های اپلیکیشن های اندرویدی میباشند. اگر با زبان های C، C# و جاوا کار کرده باشید متوجه میشوید که برنامه ها در این روش های برنامه نویسی از یک متد به نام  main شروع به اجرا میکنند. بر خلاف این روش ها، در اندروید نقطه شروع اپلیکیشن ها از یک Activity خاص میباشد که با توجه به شرایط مختلف، متد های متفاوتی در آن اجرا میشوند.

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

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

مثلا شما ممکن است که یک نرم افزار ایمیل را در موبایل خود باز کنید و یک سری ایمیل را ببنید. این روش معمولی استفاده از اپلیکیشن ها است که نرم افزار اجرا میشود و طبق ترتیبی که دارد کار های خودش را انجام میدهد. اما گاهی ممکن است که مثلا در یک وبسایت یا شبکه اجتماعی، گزینه “به اشتراک گذاشتن” را لمس کنید و بخواهید آن مطلب را از طریق ایمیل برای دوست خود ارسال کنید. در این وضعیت، اپلیکیشن ایمیل با ترتیب معمولی اجرا نمیشود. بلکه شما مستقیما به صفحه ارسال ایمیل در آن نرم افزار وارد خواهید شد.

مفهوم activity

بنابراین برای مدیریت این وضعیت ها و پیاده سازی الگوهای درست در برنامه نویسی اندروید، اکتیویتی ها ساخته شده اند. یعنی وقتی یک اپلیکیشن شما را به یک اپ دیگر راهنمایی میکند، یک اکتیویتی را از اپلیکیشن مقصد صدا میزند و اجرا میکند. با استفاده از این روش دیگر نیازی نیست که همه اپلیکیشن دیگر را اجرا کنیم تا کاری که میخواهیم انجام بشود. یعنی Activity ها میتوانند نقطه ورود کاربران به اپلیکیشن باشند.

اکتیویتی یک صفحه درست میکند که نرم افزار میتواند در آن، رابط کاربری خودش را درست کند. این صفحه معمولا همه فضای صفحه نمایش موبایل را پر میکند، اما میتواند از صفحه نمایش هم کوچکتر باشد و بالای صفحات دیگر نشان داده شود. بطور معمول، یک Activity، یک صفحه را در اپلیکیشن درست میکند. مثلا یکی از اکتیویتی ها میتواند صفحه اصلی را درست کند و یکی دیگر صفحه پروفایل را بسازد.

رابط کاربری چیست و چگونه باید طراحی شود؟

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

تعریف اکتیویتی

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

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

اکتیویتی یعنی چه؟

طراحی تجربه کاربری چیست؟

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


یک مقدار فنی تر، اکتیویتی دقیقا چیست؟

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

activity به عنوان مغز نرم افزار

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

پس میتوانیم بگوییم بدن ما یک شئ (Object) است که همه حالتها و اتفاقات آن توسط مغز کنترل میشود. در برنامه نویسی اندروید هم ما با مواردی مانند View، Layout و ViewGroup سر و کار داریم که رابط کاربری اپلیکیشن ما را میسازند. اما روح و مغزی که این اجزا را کنترل میکند چیست؟ همان اکتیویتی.

توضیح فنی Activity

تنها تفاوتی که در این مثال وجود دارد این است که بدن انسان یکبار در زمان تولد ساخته میشود و یکبار در زمان مرگ از بین میرود. در طول زندگی هم همه چیز توسط ذهن کنترل میشود. اما اکتیویتی میتواند یک اپلیکیشن را به تعداد نامحدود بسازد و از بین ببرد. یعنی به جز کنترل کردن اپلیکیشن، وظیفه ساخته شدن، از بین رفتن و همه حالت های دیگر در چرخه عمر اپلیکیشن را به عهده دارد.

در حقیقت اکتیویتی یک کلاس جاوا است و اگر شما میخواهید آن را بسازید، باید کلاس Activity را Implement کنید. این کلاس دارای یک فایل Layout با پسوند XML میباشد که لایه ظاهری و چینش المان های اکتیویتی روی صفحه را درون آن تنظیم می کنید. این کلاس همچنین دارای متدهایی است که چرخه عمر اکتیویتی را مدیریت میکنند. یعنی با استفاده از آنها میتوانید در شرایط مختلف، عملکرد های مختلفی را نیز برای ان تعریف کنید.

همیشه چندین اکتیویتی را میتوانید در یک اپلیکیشن داشته باشید، اما فقط یک MainActivity باید در آن وجود داشته باشد.

ساختار اکتیویتی

Activity از لحاظ ساختار به دو قسمت مختلف تقسیم میشود. هر اکتیویتی دارای دو فایل جداگانه است:

  • فایل کلاس جاوا (کدهای جاوا): این فایل یک کلاس جاوا است که هر اکتیویتی باید آن را داشته باشد. در حقیقت تمام اتفاقاتی که در Activity رخ میدهد و تمام قسمت هایی که توسط اکتیویتی کنترل میشوند، درون این فایل قرار میگیرند. به عبارت دیگر همه کدهایی که به زبان جاوا مینویسید درون این فایل هستند.
    اکتیویتی در حقیقت یک کلاس جاوا است. یعنی شما میتوانید هر کلاس جاوایی که دارید را به اکتیویتی تبدیل کنید. چطور؟ فقط باید یکی از کلاس های اکتیویتی اندروید (مثلا AppCompatActivity) را درون کلاس خودتان Extend کنید. با این کار همه ویژگی هایی که برای Activity ها در این مقاله خواندید، به آن کلاس نیز داده خواهد شد. (به این ویژگی میگن ارث بری که یکی از خاصیت های شی گرایی در برنامه نویسی هست. اگر با این موارد آشنایی ندارین، بهتره مقاله شی گرایی رو توی سایت ما بخونین).

شی گرایی چیست؟ آموزش شی گرایی جاوا

  • فایل Layout (ظاهر): این فایل نیز برای هر اکتیویتی وجود دارد و جایی است که شما باید المان های ظاهری را درون آن مرتب کنید تا روی صفحه به درستی نمایش داده شوند. پسوند این فایل ها xml است و با استفاده از یک ساختار به نام XML هم نوشته شده اند. چیزی که درون این فایل وجود دارد تنها المان های ظاهری و تنظیم مکان قرارگیری آنهاست. در قسمت ساخت اکتیویتی ها کاملا با این ساختار آشنا خواهیم شد.

چرخه عمر اکتیویتی

چرخه عمر اکتیویتی

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

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

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

چرخه عمر اکتیویتی ها با استفاده از چند متد کنترل میشود و شما میتوانید این متد ها را در هر Activity که دارید پیاده سازی کنید و کدهای مورد نیاز خودتان را درون آنها بنویسید.

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


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

همانطور که گفته شد برای کنترل LifeCycle اکتیویتی ها، باید از متدهای چرخه عمر استفاده کنیم. همه این متد ها را در این بخش میتوانید مشاهده کنید:

چرخه عمر اکتیویتی

متد onCreate

شما باید این متد را Implement کنید. یعنی باید آن را در اکتیویتی جدیدی که خودتان ساخته اید، پیاده سازی کندید. زیرا این متد اولین متدی است که بعد از ساخته شدن اکتیویتی اجرا خواهد شد. اینجا جایی است که شما باید کامپوننت های اصلی و حیاتی Activity خودتان را مقدار دهی اولیه کنید. مثلا اپلیکیشن شما در این قسمت باید View ها را بسازد یا اینکه دیتا ها را درون لیست های مربوطه بریزد. یکی دیگر از کارهایی که باید در این متد انجام بدهید، صدا زدن متد setContentView است که با استفاده از آن ارتباط میان فایل کلاس اکتیویتی و فایل Layout برقرار میشود.

وقتی که متد onCreate کاملا اجرا شود، بعد از آن همیشه متد onStart صدا زده خواهد شد.


متد onStart

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


متد onResume

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

متد بعدی، یعنی onPause، همیشه به دنبال متد onResume اجرا میشود (البته منظور بلافاصله نیست، از لحاظ تقدم و ترتیب اجرا اینجوری هستن).


متد onPause

سیستم عامل هنگامی متد onPause را صدا میزند که فوکوس از روی اکتیویتی برداشته شود و به حالت Pause یا نگه داشته شدن وارد شود. این وضعیت وقتی به وجود می آید که کاربر مثلا دکمه Back یا Recent App را لمس کند. وقتی که این متد برای Activity شما صدا زده میشود، به این معنی است که بخش هایی از اکتیویتی هنوز هم قابل دیدن هستند، اما این وضعیت معمولا نشانه ای است بکه کاربر در حال ترک کردن اکتیویتی شماست و به زودی به مرحله Stopped یا Resumed وارد میشود.

یک اکتیویتی در وضعیت Paused میتواند رابط کاربری را به روز رسانی نماید. مثلا اگر یک نرم افزار مسیریابی یا پخش کننده موسیقی ساختید، کاربر انتظار دارد که وقتی به اپلیکیشن بر میگردد، تغییراتی در ظاهر را مشاهده کند.

به یاد داشته باشید که نباید از این متد onPause برای ذخیره کردن اطلاعات اپلیکیشن یا کاربر، ارتباط با شبکه یا اجرای دستورات روی پایگاه داده استفاده کنید.

وقتی که اجرای onPause تمام شود، متد بعدی که صدا زده میشود میتواند onStop یا onResume باشد. بستگی دارد که بعد از وارد شدن به وضعیت Paused چه اتفاقی رخ خواهد داد.


متد onStop

سیستم عامل متد onStop را زمانی اجرا میکند که اکتیویتی دیگر برای کاربر قابل دیدن نباشد. این موقعیت میتواند به این دلایل رخ بدهد:

  • اکتیویتی در حال نابود شدن باشد
  • یک اکتیویتی دیگر در حال شروع شدن است
  • یک Activity که از قبل وجود داشته است، دوباره به حالت Resumed برگشته و اکتیویتی فعلی را میپوشاند

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


متد onRestart

این متد زمانی صدا زده میشود که اکتیویتی به حالت Stopped رفته و بخواهد دوباره شروع به کار کند. متد onRestart وضعیت Activity را به زمانی که متوقف شده بود بازمیگرداند. همیشه بعد از این متد، متد onStart اجرا میشود.


متد onDestroy

سیستم عامل قبل از اینکه اکتیویتی نابود شود، متد onDestroy را اجرا میکند. این متد آخرین تکه از چرخه عمر اکتیویتی است. این متد به این دلیل استفاده میشود که مطمئن شوید همه منابعی که Activity از آنها استفاده کرده بود، آزاد و نابود شده اند.


جمع بندی متدهای چرخه عمر

متدتوضیحاتKillableمتد بعدی
onCreateهنگامی که اکتیویتی اولین بار ساخته شد، صدا زده میشود. اینجا جایی است که شما باید همه تنظیمات استاتیک و معمولی خود را انجام بدهید. کارهایی مانند: ساخت Viewها،متصل کردن داده ها به لیست ها و غیره. این متد همچنین یک Bundle برای شما مهیا میکند که حاوی حالت قبلی فریز شده اکتیویتی است. همیشه نیز onStart به دنبال آن می آید.خیرonStart
onRestartبعد از اینکه اکتیویتی متوقف شد و دوباره شروع به کار کرد، صدا زده میشود. همیشه به دنبال آن onStart اجرا میشود.خیرonStart
onStartوقتی که اکتیویتی بخواهد برای کاربر نمایش داده شود، صدا زده میشود. اگر Activity روی صفحه نمایش داده شود بعد از آن onResume اجرا میشود. اما اگر اکتیویتی نشان داده نشود، onStop صدا زده خواهد شد.خیرonResume
یا onStop
onResumeوقتی که اکتیویتی شروع به تعامل با کاربر میکند، صدا زده میشود. در این زمان، اکتیویتی در بالای Activity Stack قرار دارد و ورودی های کاربر به آن هدایت میشود. همیشه متد بعدی آن، onPause است.خیرonPause
onPauseهنگامی که اکتیویتی دیگر روی صفحه نمایش نباشد، یا وقتی که در حال انتقال به حالت Stopped یا Hidden باشد، این متد صدا زده میشود. از آنجایی که Activity هنوز هم برای کاربر قابل دیدن میباشد، بهتر است آن را از لحاظ دیداری فعال نگه دارید و رابط کاربری را هچنان بروز رسانی کنید. پیاده سازی این متد باید بسیار سریع باشد، چون اگر این متد بازگشت داده نشود، اکتیویتی بعدی Resume نخواهد شد. بعد از این متد میتواند onResume باشد، اگر Activity به روی صفحه بازگردد، و میتواند onStop باشد اگر اکتیویتی از دید کاربر پنهان شود.Pre-Build.VERSION_CODES.HONEYCOMBonResume
یا onStop
onStopزمانی که اکتیویتی دیگر برای کاربر قابل دیدن نباشد، این متد صدا زده میشود. دلیل این کار میتواند شروع شدن یک Activity روی صفحه، نمایش یک اکتیوتی قبلی بر روی این اکتیویتی یا تخریب شدن این اکتیویتی باشد. همچنین این متد معمولا برای متوقف کردن انیمیشن ها و Refresh کردن رابط کاربری استفاده میشود.
بعد از این متد میتواند onRestart باشد اگر Activity به صفحه برگردد تا با کاربر تعامل داشته باشد، یا onDestroy باشد اگر اکتیویتی از بین برود.
بلهonRestart
یا
onDestroy
onDestroyآخرین متدی که قبل از تخریب اکتیویتی صدا زده میشود. حتی گاهی اگر متد finish را روی Activity صدا بزنید، این متد اجرا میشود. همچنین گاهی به این دلیل صدا زده میشود که سیستم این اکتیویتی را از بین میبرد تا فضای بیشتری موجود شود.بلههیچ چیز

برای متدهایی که به عنوان Killable تعریف شده اند، باید یک نکته را بدانید. Process هایی که میزبان اکتیویتی هایی هستند که این متد ها را صدا زده اند، میتوانند بدون هیچگونه هشداری توسط سیستم بسته شوند. بدون اینکه حتی یک خط دیگر از کدهای آنها اجرا شود. به همین دلیل شما باید از متد onPause برای نوشتن اطلاعات روی Storage استفاده کنید.


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

حلقه های کلیدی در

در زمانی که یک اکتیویتی چرخه های عمر را میگذراند، سه حلقه کلیدی وجود دارد که ممکن است آنها را طی نماید. آشنایی با این حلقه های کلیدی میتواند به آنالیز و بررسی بهتر LifeCycle کمک کند. حلقه های کلیدی اینها هستند:

  1. همه چرخه عمر اکتیویتی، بین اولین صدا زدن onCreate(Bundle) تا آخرین صدا زدن متد onDestryo() اتفاق می افتد. یک Activity، همه تنظیمات مربوط به حالت global را در onCreate انجام میدهد، و همه منابع باقی مانده را در onDestroy آزاد میکند. به عنوان مثال، اکتیویتی ممکن است یک Thread در پس زمینه داشته باشد که در حال دانلود اطلاعات از شبکه است. ممکن است این Thread در OnCreate درست شود و در onDestroy از بین میرود.
  2. چرخه عمر دیداری یک اکتیویتی در میان اولین صدا زدن متد onStart و در نهایت صدا زدن متد onStop رخ میدهد. در طول این زمان، کاربر میتواند اکتیویتی را روی صفحه مشاهده کند، هرچند ممکن است در بالای لیست Stack نباشد و کاربر نتواند با آن تعامل داشته باشد. در بین این دو متد، شما میتوانید منابعی که برای نشان داده شدن Activity به کاربر مورد نیاز است را حفظ و تامین نمایید. به عنوان مثال، شما میتوانید یک BroadcastReceiver را در onStart ثبت کنید تا همه تغییراتی که رابط کاربری شما را تحت تاثیر قرار بدهد دنبال کنید. سپس میتوانید آن را در onStop متوقف کنید، یعنی جایی که کاربر دیگر نمیتواند ببیند چه چیزی نمایش داده میشود. متد های onStart و onStop میتوانند چندین مرتبه صدا زده شوند، به هر تعداد مرتبه ای که اکتیویتی برای کاربر نشان داده شده و پنهان میشود.
  3. چرخه عمر روی صفحه نمایش یک اکتیویتی میان صدا زدن متد onResume و متد onPause رخ میدهد. در طول این زمان، اکتیویتی روی صفحه نمایش نشان داده میشود و کاربر میتواند با آن تعامل داشته باشد. یک Activity میتواند به دفعات زیاد بین حالت های Paused و Resumed جابجا شود. به عنوان مثال وقتی که دستگاه به حالت Sleep میرود، وقتی که نتایج یک اکتیویتی منتقل میشود یا یک Intent جدید میرسد. پس کدهای درون این متد ها باید تقریبا سبک باشد.

چگونه در اندروید استودیو اکتیویتی بسازیم؟

چگونه در اندروید استودیو Activity بسازیم؟

وقتی که یک پروژه جدید در اندروید استودیو میسازید، این پروژه از ابتدا شامل یک اکتیویتی خواهد بود، مگر اینکه خودتان انتخاب کنید یک پروژه خالی ساخته شود. در ابتدای ساخت یک پروژه میتوانید انتخاب کنید که چه نوعی از Activity برای شما ساخته شود. یا اینکه متیوانید بعد از ساخته شدن پروژه با استفاده از منوهای موجود در اندروید استودیو اکتیویتی را به پروژه اضافه کنید. راه دیگری هم هست که میتوانید یک فایل کلاس جاوا و یک فایل Layout بنویسید و آنها را به اکتیویتی تبدیل کنید. در این قسمت از مقاله قصد داریم هر سه روش را بررسی کنیم.


روش اول – ساخت اکتیویتی در ابتدای پروژه

هنگامی که میخواهید یک پروژه جدید در اندروید استودیو بسازید، همیشه از شما سوال میشود که آیا اکتیویتی خاصی درون پروژه ساخته شود یا اینکه یک پروژه خالی میخواهید؟ گام های زیر را برای ساخت اولین اکتیویتی در پروژه خودتان طی کنید:

برای دیدن هر کدام از عکس ها با کیفیت اصلی، کافیست روی آنها کلیک کنید.

گام اول – یک پروژه جدید در اندروید استودیو بسازید

ساخت اکتیویتی

برای اینکه یک پروژه در اندروید استودیو داشته باشیم، ابتدا نرم افزار را باز میکنیم، یک پنچره کوچک باز خواهد شد. بر روی گزینه Start a new Android Studio project کلیک میکنیم. با این کار یک پروژه جدید در اندروید استودیو برای شما ساخته میشود.


گام دوم – یک نوع اکتیویتی را انتخاب کنید

انتخاب اکتیویتی

بعد از اینکه یک پروژه را شروع کردید، باید انتخاب کنید که آیا از قبل یک اکتیویتی درون آن وجود داشته باشد یا خیر؟ برای این کار یک پنجره باز میشود که درون آن تعدادی از انواع اکتیوتی وجود دارد که شما میتوانید از میان آنها انتخاب کنید. یا اینکه با زدن گزینه No Activity یک پروژه کاملا خالی و بدون Activity بسازید. اما در این مرحله ما گزینه Empty Activity را انتخاب میکنیم که یک اکتیویتی خالی را برای ما بصورت اتوماتیک درون پروژه ایجاد میکند.


گام سوم – نام پروژه و تنظیمات اولیه را تعیین کنید

تنظیمات Activity

در این مرحله باید نام و تنظیمات اولیه پروژه اندروید را مشخص کنید. در قسمت ۱ باید نام پروژه یا همان نام اپلیکیشن نوشته شود. در کادر قسمت ۲ باید نام پکیج را بنویسید. در این قسمت معمولا آدرس سایت سازنده را بصورت وارونه مینویسیم. به عنوان مثال ما عبارت com.barnamechi.test را در این کادر مینویسیم. در قسمت ۳ باید مکان ذخیره شدن اپلیکیشن را مشخص کنیم. دقت کنید که در این آدرس نباید فاصله خالی یا حروف غیر انگلیسی وجود داشته باشد. قسمت ۴ هم مربوط به انتخاب API اندروید است. یعنی مشخص میکنید این اپلیکیشن روی چه ورژن هایی از اندروید نصب شود.


گام چهارم – اکتیویتی ساخته شده است

فایل های اکتیویتی

در این قسمت میتوانید در درخت پروژه مشاهده کنید که هر دو فایل کلاس جاوا و فایل layout برای اکتیویتی ساخته شده و وجود دارند.

دقت کنید که مدل نمایش درخت پروژه بهتر است که روی گزینه Package تنظیم شده باشد. (به کادر بالایی قسمت درخت پروژه دقت کنین)

روش دوم – Add کردن اکتیویتی

شما حتما در جریان ساخت یک پروژه نیاز به ساخت اکتیویتی های مختلفی خواهید داشت. برای اینکار میتوانید از دو روشی که در ادامه گفته شده است استفاده نمایید. گام های زیر را دنبال کنید:


گام اول – از منوی New، گزینه Activity را انتخاب کنید

اضافه کردن اکتیویتی به پروژه

برای اضافه کردن اکتیویتی های اندروید بصورت مستقیم درون پروژه، باید روی فولدری که میخواهید اکتیویتی در آنجا باشد کلیک راست کنید، سپس گزینه New، گزینه Activity و یکی از انواع اکتیویتی ها را انتخاب کنید.


گام دوم – نام اکتیویتی را تعیین کنید

گام دوم اضافه کردن اکتیویتی به پروژه

بعد از انتخاب یکی از اکتیویتی ها، یک پنجره باز میشود که در قسمت ۱ باید نام فایل کلاس اکتیویتی را وارد کنید، در قسمت ۲ هم باید نام فایل Layout آن را وارد نمایید. بعد از کلیک کردن روی گزینه Finish، هردوی این فایل ها ساخته میشوند و ارتباط میان آنها هم بصورت اتوماتیک برقرار خواهد شد.

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

گام سوم – اکتیویتی مورد نظر شما با موفقیت ساخته شد

فایل های Activity

اکنون میتوانید در درخت پروژه اندروید مشاهده کنید که فایل های کلاس و Layout ساخته شده و وجود دارند.


روش سوم – ساخت کلاس و لایوت دستی

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


گام اول – از منوی New گزینه Java Class را انتخاب کنید

انتخاب java class

برای این کار باید ابتدا یک فایل کلاس جاوا بسازیم. روی فولدری که میخواهیم اکتیویتی درون آن وجود داشته باشد، کلیک راست میکنیم و از گزینه New، گزینه Java Class را انتخاب میکنیم. با این کار یک کلاس جاوا برای ما ساخته خواهد شد.


گام دوم – نام کلاس و تنظیمات اولیه را تعیین کنید

انتخاب نام کلاس جاوا

بعد از انتخاب گزینه ساخت کلاس، یک پنجره باز میشود که میتوانید در آن نام کلاس جاوا را وارد کنید. چون کلاسی که میسازیم از نوع اکتیویتی است و یک کلاس جاوا است، باید ابتدای هر کلمه موجود در آن با حروف بزرگ باشد، فاصله خالی نداشته باشد، و کلمه Activity در انتهای نام آن نوشته شود. پس ما نام این Activity را MainActivity3 قرار میدهیم. (چون دوتا اکتیویتی قبلی که با هم توی این مقاله ساختیم هم وجود دارن، عدد ۳ رو اضافه میکنیم که نام ها تکراری نباشن).


گام سوم – ارث بری از یک کلاس اکتیویتی را اضافه کنید

ارث بری از کلاس Activity

اکتیویتی یک ساب کلاس از کلاس android.app.Activity است. یعنی اگر بخواهیم یک کلاس عادی جاوا را به یک اکتیویتی تبدیل کنیم، باید ارث بری از یکی از کلاس های اکتیویتی اندروید را به آن اضافه کنیم. برای این کار باید بعد از نام کلاس، کلمه extend را بنویسیم و سپس اسم کلاس مورد نظر را بیاوریم. من از کلاس AppCompatActivity استفاده کرده ام که یکی از کلاس های اکتیویتی اندروید است.


گام چهارم – فایل Layout را بسازید

ساخت فایل Layout

همانطور که گفته شد، هر اکتیویتی اندروید نیاز به یک فایل Layout برای تنظیم ظاهر المان های آن میباشد. بنابراین باید در پوشه res وارد شده و سپس در پوشه layout، یک فایل بسازیم. برای اینکار روی فولدر layout کلیک راست میکنیم، از گزینه New، گزینه Android Resouce File را انتخاب میکنیم.

انتخاب نام فایل لایوت

بعد از انتخاب ساخت این فایل، یک پنجره کوچک باز میشود که از شما میخواهد نام را وارد کنید. ما نام فایل را بصورت activity_main3 تعیین میکنیم و گزینه OK را میزنیم. (یجوری اسم ها رو انتخاب کنین که اگر شونصد تا فایل توی پروژه ساختین، معلوم باشه چی به چیه. البته قواعد نام گذاری مختلفی وجود داره برای اندروید که به زودی اونها رو باهم بررسی میکنیم).


گام پنجم – ارتباط میان فایل Layout و کلاس اکتیویتی را برقرار نمایید

ارتباط میان کلاس و layout یک اکتیویتی

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

بعد از اینکار، یک متد را باید درون متد onCreate صدا بزنید و اسم فایل Layout را به آن ارسال کنید. بنابراین متد setContentView را صدا میزنیم و برای دسترسی به فایل Layout، باید مقدار R.layout.activity_main3 را به آن پاس بدهیم. با این کار ارتباط میان اکتیویتی و فایل Layout آن برقرار میشود.


گام ششم – اکتیویتی شما ساخته شده است

قایل های اکتیویتی

بعد از اینکار میتوانید ببینید که اکتیویتی شما ساخته شده است. فایل های آن هم در درخت پروژه مشخص و قابل دیدن میباشند.


تنظیمات Manifest

برای اینکه اپلیکیشن شما بتواند از Activity هایی که ساخته اید استفاده کند، شما باید اکتیویتی ها را در فایل AndroidManifest.xml تعریف کنید و Attribute های آن را هم درون آن قرار بدهید. مراحل زیر را طی کنید.


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

برای تعریف اکتیویتی ها، باید AndroidManifest.xml راباز کنید و یک تگ <activity> به عنوان فرزند المان <application> درون آن تعریف کنید. یعنی باید کدهایی به این شکل داشته باشید:

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

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


تعریف Intent Filter برای اکتیویتی

اکتیویتی ها نیاز به یک سری موارد و تنظیمات اضافه دارند تا توسط سیستم اندروید شناخته شوند.  این فیلتر ها یکی از آن موارد هستند. برای اینکه با Intent Filter ها آشنا شوید و بتوانید از آنها استفاده کنید، باید ابتدا در مورد مفهوم Intent ها مطالبی را یاد بگیریم و بعد به Intent Filter خواهیم پرداخت.


Intent چیست؟

Intent چیست؟

Intent یک ساختار انتقال پیام است که با استفاده از آن میتوانید بین همه کامپوننت های اندروید ارتباط برقرار کنید. همچنین این ساختار میتواند پیام هایی را نیز برای کامپوننت های مختلف جابجا کند. مثلا میتوانیم با Intent ها پیام هایی را میان اکتیویتی های مختلف و دیگر کامپوننت های اندروید رد و بدل کنیم. در کل دو نوع Intent داریم:

  • ضمنی (Implicit): های ضمنی برای تعریف کردن یک سری وظیفه به کار میروند، و سپس همه اپلیکیشن هایی که توانایی انجام آن وظیفه را دارند، میتوانند انجامش بدهند. دلیل نام Implicit یا ضمنی این است که در این مدل از Intent ها شما مقصد را به صورت واضح مشخص نمیکنید. فقط Task را تعرف میکنید و هر اپلیکیشنی که توانایی انجام آن را داشته باشد، آنرا به عهده میگیرد. به عنوان مثال شاید یک اپلیکیشن نیاز داشته باشد که یک عکس را باز کند. شما میتوانید با تعریف یک Implicit Intent از یک نرم افزار دیگر (مثلا گالری) استفاده کنید تا آن عکس را برای شما باز کند.
  • صریح (Explicit): از Intent های Explicit برای باز کردن یک اکتیویتی از درون یک Activity دیگر که هردو در یک اپلیکیشن قراردارند استفاده میشود. دلیل نام Explicit یا صریح این است که در این مدل، باید دقیقا مشخث کنید که کدام اکتیویتی باید توسط این Intent باز شود. مثلا شما میتوانید از اکتیویتی اصلی، صفحه Activity حساب کاربری را در اپلیکیشن خودتان باز کنید.

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

آشنایی با Intent Filter ها

Intent Filter ها یکی از قدرتمند ترین ویژگی های پلتفرم اندروید هستند. آنها شما را قادر میکنند که یک اکتیویتی را نه فقط با استفاده از Intent های Explicit، بلکه با درخواست های Implicit هم اجرا کنید. به عنوان مثال، یک درخواست Explicit ممکن است به سیستم درخواست بدهد که “اکتیوتی ارسال ایمیل را در نرم افزار Gmail باز کن”. اما دقیقا در نقطه مخالف، یک درخواست Implicit به سیستم میگوید “یک صفحه ارسال ایمیل در هر اکتیویتی که توانایی انجام آن را دارد باز کن”. وقتی که کاربر اپلیکیشن مورد نظر را انتخاب میکند، این کار از طریق Intent Filter انجام میشود.

شما میتوانید با تعریف کردن یک <intent-filter> در المان <activity> از مزیت های این ویژگی استفاده کنید. برای تعریف کردن این المان، باید درون آن یک المان <action> داشته باشید، همچنین یک المان <category> و یک المان <data> هم میتوانند به دلخواه درون آن قرار بگیرند.

این المان ها ترکیب میشوند تا مشخص کنند اکتیویتی به چه نوع Intent هایی میتواند پاسخ بدهد. به عنوان مثال تکه کد زیر به شما نشان میدهد که چگونه یک Activity که اطلاعات متنی میفرستد و از اکتیویتی های دیگر هم برای انجام این کار، درخواست دریافت میکند.

<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> مشخص میکند که چه نوعی از داده ها میتوانند توسط این Activity ارسال شوند. تکه کد زیر نشان میدهد چگونه میتوانید این اکتیویتی را  با روشی که گفته شد صدا بزنید.

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

البته اگر میخواهید اپلیکیشن شما از بیرون بی نیاز باشد و به بقیه اپلیکیشن ها اجازه ندهید اکتیویتی های آن را فعال کنند، شما به هیچ Intent Filter دیگری نیاز ندارید. یعنی اکتیویتی هایی که نمیخواهید برای اپلیکیشن های دیگر قابل دیدن باشند، نباید Intent Filter درون آنها وجود داشته باشد، در اینصورت شما فقط خودتان میتوانید آنها را با استفاده از Intent های Explicit اجرا کنید.


تعریف کردن Permission ها برای اکتیویتی

شما میتوانید از تگ <activity> در Manifest برای کنترل کردن اینکه کدام اپلیکیشن میتواند یک اکتیویتی مشخص را اجرا کند، استفاده کنید. یک اکتیویتی مادر، نمیتواند یک اکتیویتی فرزند را صدا کند مگر اینکه هردو Permission های یکسانی را در Manifest خود داشته باشند. اگر شما یک المان <uses-permission> را در اکتیویتی مادر اضافه کنید، هر Activity فرزند باید همان تگ <uses-permission> را داشته باشد.

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

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

/>

سپس، برای اینکه اجازه داشته باشید SocialApp را اجرا کنید، اپلیکیشن دیگر باید دقیقا همین Permission های SocialApp را داشته باشد. کد زیر را مشاهده کنید.

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

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


جمع بندی

جمع بندی

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


سوالی دارید؟

سوال دارید؟

اگر در مورد ساخت اکتیویتی های اندروید و کار کردن با آنها سوالی در ذهن شما وجود دارد، آن را در قسمت نظرات (همین پایین) بنویسید. همچنین شاید خیلی از شما تجربه کار کردن با اکتیویتی های اندروید را داشته باشید. میتوانید تجربه های خودتان را با ما و دیگران در نطرات به اشتراک بگذارید و این مقاله آموزشی را کامل تر کنید.


منابع بیشتر برای مطالعه

میتوانید از منابع زیر برای مطالعه بیشتر در این زمینه استفاده کنید:

علی خانقلی

به برنامه نویسی و مخصوصا برنامه نویسی اندروید علاقه بسیار زیادی دارم. همه تلاشم هم اینه که با "برنامه چی" بتونم برنامه نویسی رو برای همه خیلی راحت کنم. به وبسایت ما خوش اومدین! 😉

دیدگاهتان را بنویسید

نشانی ایمیل شما منتشر نخواهد شد. بخش‌های موردنیاز علامت‌گذاری شده‌اند *

دکمه بازگشت به بالا
بستن
بستن