DEV Community: Papon Ahasan

Set Up Flutter + FVM + Create Project on a New Computer

Papon Ahasan — Sat, 18 Oct 2025 02:15:53 +0000

🛠 Step-by-Step: Set Up Flutter + FVM + Create Project on a New Computer

1️⃣ Install Dart (required for FVM)

macOS/Linux:

brew install dart        # macOS
sudo apt install dart    # Ubuntu/Debian

Windows: download from Dart SDK and follow instructions.

Check Dart:

dart --version

2️⃣ Install FVM

dart pub global activate fvm

Add FVM to PATH (Linux/macOS):

export PATH="$PATH":"$HOME/.pub-cache/bin"

Check FVM:

fvm --version

3️⃣ Install Flutter version via FVM

fvm install stable

Optional: set global default version:

fvm global stable

4️⃣ Create new Flutter project

fvm flutter create my_first_app
cd my_first_app

5️⃣ Lock project to FVM version

fvm use stable

6️⃣ Get dependencies

fvm flutter pub get

7️⃣ Run the app

fvm flutter run

✅ Summary: What You Needed

Install Dart (required for FVM)
Install FVM (dart pub global activate fvm)
Install Flutter version (fvm install stable)
Set IDE Flutter SDK path → point to FVM version
Create project (Android Studio or terminal)
Run app
Use fvm flutter pub get for dependencies

💡 Pro Tip:
After this setup, you can work offline for a project, because FVM keeps the Flutter SDK and packages cached.

Android SDK

Papon Ahasan — Tue, 19 Aug 2025 09:19:10 +0000

Android SDK or software development kit হলো বিভিন্ন টুলস, লাইব্রেরি এবং ডকুমেন্টস এর একটি সংগ্রহ যা ডেভেলপারদের অ্যান্ড্রয়েড অ্যাপ্লিকেশন তৈরি করতে সাহায্য করে। এই টুলসগুলো ব্যবহার করে অ্যাপ্লিকেশন ডেভেলপ করা, ডিবাগ করা এবং টেস্ট করা যায়।

The SDK includes the Android SDK Platform, the Android SDK Tools, and the Android SDK Documentation.

Android SDK Platform : বিভিন্ন অ্যান্ড্রয়েড সংস্করণের জন্য প্রয়োজনীয় প্ল্যাটফর্ম কম্পোনেন্টগুলো ধারণ করে। প্রতিটি প্ল্যাটফর্ম একটি নির্দিষ্ট অ্যান্ড্রয়েড API লেভেলের সাথে সম্পর্কিত। প্রতিটি অ্যান্ড্রয়েড সংস্করণের একটি নির্দিষ্ট API লেভেল থাকে। যত বেশি API লেভেল সাপোর্ট করা হবে, তত বেশি অ্যান্ড্রয়েড সংস্করণ এবং ডিভাইসে আপনার অ্যাপ চলবে।

Example: Android 16.0 ("Baklava") (API Level 36): এটি অ্যান্ড্রয়েডের ১৬.০ সংস্করণ, যার API লেভেল ৩৬। আপনার স্ক্রিনশটে এটি ইন্সটল করা আছে দেখা যাচ্ছে।

Android SDK Platform 36: এটি অ্যান্ড্রয়েড ১৬.০ এর মূল প্ল্যাটফর্ম যা অ্যাপ ডেভেলপমেন্টের জন্য প্রয়োজনীয় লাইব্রেরি এবং রিসোর্স সরবরাহ করে।
Sources for Android 36: এটি Android 16.0 এর সোর্স কোড, যা ডেভেলপারদের ডিবাগিং এর সময় কাজে লাগে। এটি ইন্সটল থাকলে কোডের গভীরে গিয়ে সমস্যা খুঁজে বের করা সহজ হয়।
Google APIs (Google APIs): গুগল সার্ভিস (যেমন Google Maps, Google Play Services) ব্যবহার করার জন্য প্রয়োজনীয় লাইব্রেরি এবং রিসোর্স। আপনার স্ক্রিনশটে Google APIs ARM 64 v8a System Image এবং Google Play System Image ইন্সটল করা আছে, যা এমুলেটরে Google Play Store সহ অ্যাপ চালানোর জন্য জরুরি।
System Images (সিস্টেম ইমেজ): এমুলেটরে অ্যান্ড্রয়েড ডিভাইস সিমুলেট করার জন্য এই ইমেজগুলো ব্যবহার করা হয়। ARM 64 v8a, Intel x86 Atom ইত্যাদি বিভিন্ন আর্কিটেকচারের জন্য সিস্টেম ইমেজ থাকে। আপনার স্ক্রিনশটে "Wear OS" এবং "Google TV" এর জন্য সিস্টেম ইমেজ Not installed দেখা যাচ্ছে।

Android SDK Tools include a debugger, a handset emulator, and a variety of other tools that developers use to build and test Android apps.

Android SDK Build-Tools (অ্যান্ড্রয়েড SDK বিল্ড-টুলস): এটি অ্যাপ্লিকেশনের সোর্স কোড কম্পাইল, বিল্ড এবং প্যাকেজ করার জন্য প্রয়োজনীয় টুলস ধারণ করে। উদাহরণস্বরূপ, aapt (Android Asset Packaging Tool) এবং dx (Dalvik Executable) টুলস এখানে থাকে। সাধারণত সর্বশেষ সংস্করণ ব্যবহার করা হয়, তবে পুরনো প্রোজেক্টগুলোর জন্য পুরনো সংস্করণও রাখা হয়।
Android Emulator (অ্যান্ড্রয়েড এমুলেটর): এটি একটি ভার্চুয়াল অ্যান্ড্রয়েড ডিভাইস যা আপনার কম্পিউটারে চলে। আপনার অ্যাপ পরীক্ষা করার জন্য এটি ব্যবহার করা হয়।
Android SDK Platform-Tools (অ্যান্ড্রয়েড SDK প্ল্যাটফর্ম-টুলস): এই প্যাকেজে adb (Android Debug Bridge), fastboot ইত্যাদি টুলস থাকে। adb একটি শক্তিশালী কমান্ড-লাইন টুল যা ডিভাইস এবং এমুলেটরের সাথে যোগাযোগ করতে এবং অ্যাপ ডিবাগ করতে ব্যবহৃত হয়।
Android Support Repository (অ্যান্ড্রয়েড সাপোর্ট রিপোজিটরি): এতে বিভিন্ন সাপোর্ট লাইব্রেরি এবং কম্প্যাটিবিলিটি প্যাকেজ থাকে যা পুরোনো অ্যান্ড্রয়েড সংস্করণগুলিতে নতুন ফিচার ব্যবহার করতে সাহায্য করে।
Google Play services (গুগল প্লে সার্ভিসেস): Google Play services এ API-এর একটি সেট রয়েছে যা Android অ্যাপকে Google-এর ফিচারগুলির সাথে ইন্টারঅ্যাক্ট করতে দেয়, যেমন লোকেশন, সাইন-ইন, অ্যাডভারটাইজিং ইত্যাদি।
Google Repository (গুগল রিপোজিটরি): এতে Google-এর নিজস্ব লাইব্রেরি এবং আর্টিফ্যাক্ট থাকে যা Google-এর বিভিন্ন পরিষেবা এবং বৈশিষ্ট্য ব্যবহার করার জন্য প্রয়োজনীয়।
NDK (Side by side) (NDK): Native Development Kit। যদি আপনি C বা C++ কোড দিয়ে অ্যান্ড্রয়েড অ্যাপ ডেভেলপ করতে চান, তাহলে এটি প্রয়োজন হবে।
CMake: C/C++ প্রোজেক্টগুলো বিল্ড করার জন্য এটি একটি বিল্ড অটোমেশন টুল।
Android SDK Command-line Tools (অ্যান্ড্রয়েড SDK কমান্ড-লাইন টুলস): Android Studio GUI ছাড়াই SDK উপাদানগুলি ম্যানেজ করার জন্য কমান্ড-লাইন টুলস।

The Android SDK Documentation includes tutorials, reference documentation, and other resources that help developers learn how to use the Android SDK.

SDK Update Sites (SDK আপডেট সাইট): এই অংশটি নির্দিষ্ট URL গুলি দেখায় যেখান থেকে অ্যান্ড্রয়েড SDK কম্পোনেন্টগুলি আপডেট বা নতুন কম্পোনেন্ট ডাউনলোড করা হয়। এটি নিশ্চিত করে যে আপনার কাছে সর্বদা সর্বশেষ SDK এবং এমুলেটর ইমেজ রয়েছে।

এখানে বিভিন্ন ধরনের সিস্টেম ইমেজ, যেমন Automotive, Desktop, TV, Wear, Tablet ইত্যাদি জন্য URL গুলি তালিকাভুক্ত করা আছে। এগুলি সাধারণত স্বয়ংক্রিয়ভাবে চেক করা হয়, তবে আপনি ম্যানুয়ালি নতুন সাইট যোগ করতে পারেন যদি আপনার বিশেষ কোনো রিপোজিটরি থেকে কিছু প্রয়োজন হয়।

Android SDK Location (অ্যান্ড্রয়েড SDK লোকেশন): এটি আপনার সিস্টেমে অ্যান্ড্রয়েড SDK কোথায় ইন্সটল করা আছে তার পাথ (location) দেখায়। আপনার ক্ষেত্রে এটি /Users/rakibulahesan/Library/Android/sdk। এই ফোল্ডারের মধ্যেই platforms, build-tools, platform-tools ইত্যাদি ফোল্ডারগুলো থাকে।

Gradle Settings (গ্রেডল সেটিংস):

Project Structure (প্রোজেক্ট স্ট্রাকচার)

The benefits of Android SDK are that, make it easy to build, takes less time and tests Android apps. I have used the Android SDK to develop a variety of Android apps, including a social media app, a news app, and a game.

https://outcomeschool.com/blog/unit-testing-viewmodel-with-kotlin-flow-and-stateflow

CI/CD using GitHub Actions

Papon Ahasan — Fri, 25 Jul 2025 19:35:09 +0000

🧠 What is CI/CD?

ধরো তুমি প্রতিদিন স্কুলে গিয়ে ছবি আঁকো। তোমার টিচার চায়, তুমি আঁকা শেষ করলেই সেটা তাকে দেখাও — যাতে সে দেখে ঠিক আছে কিনা। এটাই CI/CD-এর মতো।

প্রতিবার তুমি ছবি আঁকো (code লেখো), সঙ্গে সঙ্গে একজন টিচার সেটা দেখে (test করে)। -> CI (Continuous Integration)

যদি ছবি ঠিক হয় (test পাস করে), তখন সেটা অটোমেটিকভাবে তোমার বন্ধুদের দেখানোর জন্য পাঠিয়ে দেওয়া হয় (release বা deploy করা হয়)। -> CD (Continuous Delivery)

CI = Continuous Integration
➤ Code push করলেই সিস্টেম অটো বিল্ড করে দেখে bug আছে কিনা
➤ Automatically build & test code after every commit/pull request
CD = Continuous Delivery or Deployment
➤ সব কিছু ঠিক থাকলে apk/build/upload করে দেয় — human ছাড়াই
➤ Automatically prepare artifacts (APK/AAB) for release
➤ Automatically push to Play Store/internal track (optional, risky for prod)

আমরা Android Studio দিয়ে অ্যাপ বানাই, Gradle দিয়ে build করি, test চালাই, APK তৈরি করিই QA বা Client কে পাঠাই। এইসব কাজ আমরা প্রতিবার নিজে নিজে করতে হয়।

CI/CD হল এমন একটা অটো সিস্টেম, যেটা আমাদের হয়ে এইসব কাজ নিজে নিজেই করে ফেলে — আমাদের কিছুই করতে হয় না!

🧰 CI/CD Tools

Benefits

Faster release cycle
fewer bugs
consistent builds

🏗️ GitHub Actions

– GitHub Actions হল একটা ছোট্ট Robot যেটা Code Push হলেই কাজ শুরু করে!

আমরা কখন কী করতে চাই, সেটা YAML এ বলে দেই(Think of GitHub Actions YAML file as a রোবটকে নির্দেশনা দেয়ার খাতা, একটা Text ফাইল, যেটা তুমি GitHub Actions বা অন্য configuration-এ ব্যবহার করো রোবটকে নির্দেশনা দিতে।)

আমরা .github/workflows/ ফোল্ডারে একটা YAML ফাইল দেই, যেমন:

your-project/
└── .github/
    └── workflows/
        └── firebase-ci.yml

এই GitHub Actions রোবট —

Code ডাউনলোড করে নেয় (checkout)
Gradle দিয়ে build করে
JUnit/Mockito দিয়ে test চালায়
সব ঠিক থাকলে ➤ APK ফাইল বানায়
তারপর ➤ Firebase App Distribution বা Google Drive-এ upload করে
চাইলে ➤ Slack, Email বা Telegram-এ notify করে দেয়

যখনই তুমি main ব্রাঞ্চে কোড push করো, তখন নিচের ধাপগুলো চলবে:

Android Lint Check: Code clean আছে কিনা, Android guideline মেনে লেখা হয়েছে কিনা — সেটা দেখে।
Unit Test: ছোট ছোট function ঠিকমতো কাজ করছে কিনা সেটা পরীক্ষা করে।
Instrumentation Test: পুরো UI/Activity সঠিকভাবে কাজ করছে কিনা দেখে।
Static Code Analysis: Code-এ ভুল ধরণ বা সমস্যা আছে কিনা দেখে (যেমন SonarQube দিয়ে)।
APK Build (Packaging): .apk ফাইল বানায়।
Functional Test: UI বাটন, স্ক্রিন ঠিকমতো রেসপন্ড করে কিনা দেখে।
Deploy: যদি সব ঠিক থাকে, তখন Firebase App Distribution বা Google Drive এ আপলোড করে দেয় — যাতে QA টিম টেস্ট করতে পারে।

Pipeline Building Blocks

These are the stages of a typical Android CI/CD pipeline:

Build Artifact Management:

Deployment & Distribution:

🧱 YAML-এর মূল কাঠামো (Structure)

একটা YAML ফাইল সাধারণত ৩টি অংশে ভাগ করা যায়:

name: এই পুরো Workflow-এর নাম (Just একটা টাইটেল).
on: কবে এই কাজগুলো চলবে? (Trigger condition)
jobs: আসল কাজগুলো, Step by Step, কী কী হবে?

বাস্তবে YAML ফাইল এর মাধ্যমে রোবটকে বলি:

name: Android Build

on:
  push:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: কোড নাও
        uses: actions/checkout@v4

      - name: JDK সেট করো
        uses: actions/setup-java@v4
        with:
          java-version: '17'

      - name: gradlew চালাও
        run: chmod +x ./gradlew

      - name: APK বানাও
        run: ./gradlew assembleDebug

      - name: APK Upload করো
        uses: actions/upload-artifact@v4
        with:
          name: app-debug.apk
          path: app/build/outputs/apk/debug/app-debug.apk

🎯 উদাহরণ:

on: push ➤ push করলে চলবে
on: pull_request ➤ PR করলে চলবে
on: schedule ➤ নির্দিষ্ট সময় অনুযায়ী চলবে

build: হল এই কাজের নাম — তুমি ইচ্ছেমতো অন্য কিছু দিতে পারো যেমন test:, deploy: ইত্যাদি।

runs-on, GitHub তোমার কাজ চালানোর জন্য একটা ভার্চুয়াল কম্পিউটার (server) চালু করবে।
runs-on: ubuntu-latest # Linux machine
runs-on: windows-latest # Windows machine
runs-on: macos-latest # Mac machine (iOS dev-এর জন্য দরকার)

GitHub Marketplace: https://github.com/marketplace

🔄 CI/CD Flow (GitHub Actions ➤ Firebase App Distribution)

এই ফ্লোটি Android অ্যাপের জন্য APK build করে Firebase-এ আপলোড করে — অটোমেটিকভাবে, যখনই main branch-এ কোড push করবে।

01: GitHub Repo তৈরি করো

02: এই .yml ফাইলটা রাখো your-project/.github/workflows/firebase-ci.yml ফাইল.

mkdir -p .github/workflows 
touch .github/workflows/firebase-ci.yml

your-project/
└── .github/
    └── workflows/
        └── firebase-ci.yml

03: Gradle wrapper (./gradlew) ফাইল যেন executable থাকে.

04: Firebase App ID সংগ্রহ করো: ➤ Firebase Console ➤ Project Settings ➤ General ➤ Android App ➤ App ID

05: Firebase Token জেনারেট করো। CLI দিয়ে লগইন করে token বানাও। কমান্ড দিয়ে : firebase login:ci। একটা লম্বা টোকেন আসবে। Copy করে রাখো।

brew install node
node -v
npm -v
npm install -g firebase-tools
firebase login:ci
firebase --version

06: GitHub Secrets সেট করো: GitHub Repo ➤ Settings ➤ Secrets and variables ➤ Actions ➤ “New repository secret” এ গিয়ে এই দুইটা key add করো

|Secret Name     |         Value                     |
|----------------|-----------------------------------|
|FIREBASE_APP_ID | Firebase Console থেকে নেয়া App ID.  |
|FIREBASE_TOKEN  | Firebase CLI দিয়ে generate করা token|

⚠ Important Warnings:

FIREBASE_TOKEN is deprecated

- You are using FIREBASE_TOKEN to authenticate.

- Firebase CLI will remove this method in a future release.

✅ Recommended: Use Service Account JSON instead.

🔒 Create Service Account & Get JSON Key:

- Go to Firebase Console → Project Settings → Service Accounts

- Click “Generate new private key” → Download the .json file

- Add the file to GitHub Secrets (name it SERVICE_ACCOUNT_JSON)

Update your GitHub Actions .yml like:

- name: Upload to Firebase App Distribution
  uses: wzieba/Firebase-Distribution-Github-Action@v1
  with:
    appId: ${{ secrets.FIREBASE_APP_ID }}
    serviceCredentialsFileContent: ${{ secrets.SERVICE_ACCOUNT_JSON }}
    file: app/build/outputs/apk/release/app-release.apk
    testers: your_email@example.com
    releaseNotes: "Automated build from GitHub Actions"

07: Firebase Console-এ গিয়ে testers বা group তৈরি:

Firebase Console ➝ App Distribution ➝ Testers & Groups
- Add testers ➝ তোমার ইমেইল অ্যাড্রেস অথবা টেস্টারদের ইমেইল যোগ করো
চাইলে Group তৈরি করে তার নাম রাখো, যেমন: internal-testers

08: এখন main branch-এ কোড push করলেই:

✅ APK build হবে
✅ Firebase App Distribution এ testers group-এ পাঠানো হবে
✅ QA টিম ফোনে Firebase থেকে install করতে পারবে

📄 firebase-ci.yml ফাইল

name: Android CI/CD - Build and Firebase Upload

on:
  push:
    branches: [ main ]  # main branch এ push হলে trigger হবে

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      # 1. কোড চেকআউট
      - name: Checkout project code
        uses: actions/checkout@v4

      # 2. JDK সেটআপ (Java 17)
      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          distribution: 'temurin'
          java-version: '17'

      # 3. gradlew পারমিশন দিন (Linux এর জন্য প্রয়োজন)
      - name: Make gradlew executable
        run: chmod +x ./gradlew

      # 4. Debug APK build করুন
      - name: Build Debug APK
        run: ./gradlew assembleDebug

      # 5. Firebase App Distribution এ আপলোড করুন
      - name: Upload to Firebase App Distribution
        uses: wzieba/Firebase-Distribution-Github-Action@v1
        with:
          appId: ${{ secrets.FIREBASE_APP_ID }}
          token: ${{ secrets.FIREBASE_TOKEN }}
          groups: "internal-testers"
          file: app/build/outputs/apk/debug/app-debug.apk
          releaseNotes: "Bug fixes and improvements"
          notifyTesters: true

https://singhajit.com/android-ci-cd-using-github-actions/

CI/CD Tools: GitHub Actions, GitLab CI, Jenkins, Bitrise, CircleCI, Fastlane

DevOps Skills: Automated build/test/deploy pipelines, Gradle optimization, Firebase App Distribution

Start with: GitHub Actions → Lint → Test → Build
Next: Add Firebase Upload + Slack Notification
Advanced: Code Quality + Play Store Automation
Use Secrets for safety (Firebase Token, API keys)

Recommended

Start with GitHub Actions
Learn Fastlane: Even if you use GitHub Actions, Fastlane handles signing, Play Store / App Store uploads, screenshots, and versioning
Explore at least one alternative
- Bitrise → for mobile apps
- GitLab CI → if you work with GitLab repos
Understand CI/CD fundamentals
- Workflow triggers: push, PR, schedule
- Environment variables and secrets
- Caching, parallel jobs
- Deploy strategies: canary, staged rollout

Ref

Tracks in Google Play

Internal Track--> Internal testing track – ছোট টিম বা নির্দিষ্ট testers-এর জন্য, খুব দ্রুত আপলোড হয়।
Alpha Track (Closed Testing)--> Closed testing track – select group of testers, release before beta/production.
Beta Track (Open Testing) --> Open testing track – larger tester group, pre-release before production.
Production Track --> Public release – সকল Play Store user-এর জন্য।

Status Parameter

completed - Build immediately published to track (not draft).
draft - Build saved as draft, manual publish needed.

whatsNew/
├─ internal/
│ └─ en-US.txt
├─ beta/
│ └─ en-US.txt
└─ production/
└─ en-US.txt

SkinBD app production release
- New features
- Bug fixes

GitFlow

1. Main Branch (Production ready code)

এখানে সবসময় stable production code থাকে।
Example: v1.0 app live আছে।

2. Develop Branch (Ongoing development)

সব developer এখানে merge করে। এটা future release এর জন্য।

3. Feature Branch তৈরি

Rakib নতুন feature বানাতে শুরু করলো:

git checkout develop &
git checkout -b feature/login-api & git commit -m "feat: add login API with JWT authentication" & 
git push origin feature/login-api

Sara UI বানাতে শুরু করলো:

git checkout develop & 
git checkout -b feature/login-ui
git commit -m "feat: add login screen with username/password fields"
git push origin feature/login-ui

4. Pull Request (PR)

Rakib GitHub/GitLab এ PR তৈরি করলো → feature/login-api → develop
CI/CD pipeline run হলো → test & build pass
Teammates review করলো, comments দিলো → Rakib fix করলো
তারপর merge approved
Sara ও একইভাবে feature/login-ui → develop PR দিলো → merge approved

5. Release Branch

Release এর সময়:
git checkout develop
git checkout -b release/v1.1
QA টিম এই branch টেস্ট করবে।
Bug fix দরকার হলে সরাসরি এই branch এ করা হবে।

6. Production Release

git checkout main
git merge release/v1.1
git tag -a v1.1 -m "Release 1.1"
git push origin main --tags

7. Hotfix Example

Production এ login bug ধরা পড়লো → hotfix branch:

git checkout main
git checkout -b hotfix/login-bug
# fix bug
git commit -m "fix: login null pointer exception"
git push origin hotfix/login-bug

PR → review → merge into main and develop.

Real-life Output:

main → v1.0 (old release), later updated to v1.1
develop → চলমান development branch
feature/login-api → Rakib এর কাজ
feature/login-ui → Sara এর কাজ
release/v1.1 → staging QA tested branch
hotfix/login-bug → production bugfix

Data Backup & Caching strategy Android

Papon Ahasan — Sat, 19 Jul 2025 00:15:30 +0000

Data Backup

<application
    android:allowBackup="false"
    android:fullBackupContent="false"
    android:usesCleartextTraffic="false"
    tools:targetApi="m">
</application>

android:allowBackup="true" এর মানে: অ্যাপ ডেটা ব্যাকআপের অনুমতি দিবে

আপনার অ্যাপের ডেটা (SharedPreferences, ফাইল, ডাটাবেস ইত্যাদি) স্বয়ংক্রিয়ভাবে ইউজারের Google অ্যাকাউন্টে ব্যাকআপ হবে। এর ফলে, যদি ইউজার ফোন বদলে বা ফ্যাক্টরি রিসেট করে, তারা তাদের অ্যাপ ডেটা পুনরায় রিস্টোর করতে পারবে।
আপনার অ্যাপ নিজে Google লগইন বা অন্য কোনো authentication সিস্টেম ব্যবহার করবে না। ব্যাকআপ-রিস্টোর ফিচারটির জন্য Android OS নিজেই কাজ করে, আপনাকে আলাদা কোড লিখতে হয় না। অর্থাৎ, ইউজার ফোনে যেকোনো Google Account লগইন করলেই, Android System সেই অ্যাকাউন্টের সাথে আপনার অ্যাপের ব্যাকআপ ডেটা সিঙ্ক করবে।
এতে ইউজারের জন্য সুবিধা: ইউজারের ডেটা হারানোর ঝুঁকি কমে। ডাটা সেফটি এবং continuity বজায় থাকে। ইউজার এক্সপেরিয়েন্স ভালো হয়।
যদি আপনার অ্যাপের ডেটায় সেন্সিটিভ তথ্য থাকে (পাসওয়ার্ড, টোকেন, ব্যাংক বা স্বাস্থ্য তথ্য), তাহলে ব্যাকআপ দেওয়া সিকিউরিটি ঝুঁকি হতে পারে। এমন ক্ষেত্রে ব্যাকআপ অফ রাখা ভালো।

২. android:fullBackupContent="true" (বা ফাইল না দিলে ডিফল্ট true ধরা হয়) এর মানে: ডিফল্ট বা নির্দিষ্ট কনফিগারেশন অনুযায়ী ব্যাকআপ

এটি নির্ধারণ করে আপনার অ্যাপের কোন কোন ডেটা ব্যাকআপ হবে।
যদি true থাকে বা কোনো ফাইল না দেওয়া হয়, তাহলে অ্যাপের সব প্রাইভেট ফাইলগুলো ব্যাকআপ হবে।
আপনি চাইলে একটি XML ফাইল দিয়ে নির্দিষ্ট ফাইল বা ফোল্ডার ব্যাকআপ থেকে বাদ দিতে পারেন। যদি আপনি ব্যাকআপ নিয়ন্ত্রণ করতে না চান, তাহল android:fullBackupContent="true" অথবা ফাইল না দিলেও চলে। তখন ডিফল্ট ভাবে সবকিছু ব্যাকআপ হয়।

কিন্তু সিকিউর বা বড় অ্যাপের ক্ষেত্রে প্রয়োজন অনুযায়ী ফাইল/ফোল্ডার বাদ দেয়া ভালো।

// res/xml/backup_rules.xml
<?xml version="1.0" encoding="utf-8"?>
<full-backup-content>
    <!-- ব্যাকআপ থেকে 'cache' ফোল্ডার বাদ দিন -->
    <exclude domain="file" path="cache/" />

    <!-- ব্যাকআপ থেকে 'temp_files' ফোল্ডার বাদ দিন -->
    <exclude domain="file" path="temp_files/" />

    <!-- ব্যাকআপ থেকে 'databases/my_db.db' বাদ দিন -->
    <exclude domain="database" path="my_db.db" />

    <!-- ব্যাকআপ থেকে SharedPreferences বাদ দিতে পারেন (optional) -->
    <!-- <exclude domain="sharedpref" path="my_prefs.xml" /> -->

    <!-- ব্যাকআপে অন্য সব কিছু অন্তর্ভুক্ত হবে -->
</full-backup-content>

// AndroidManifest.xml
<application
    android:allowBackup="true"
    android:fullBackupContent="@xml/backup_rules"
    ... >
    ...
</application>

domain বলতে বোঝায় ডেটার ধরন, যেমনঃ
- "file" = অ্যাপের ফাইল ডিরেক্টরি (internal storage)
- "database" = SQLite ডাটাবেস ফাইল
- "sharedpref" = SharedPreferences ফাইল
- path হলো সেই ফাইল বা ফোল্ডারের নাম বা লোকেশন (relative path) ফলে কি হয়? আপনি যা এক্সক্লুড (exclude) করবেন, সেই ডেটা ব্যাকআপ হবে না। বাকিটা স্বাভাবিকভাবেই ব্যাকআপে যাবে।

Caching strategy

1️⃣ LruCache – Stores data in memory and removes the least recently used items when full.
Example: Keep recently loaded images or data so they show instantly next time.

2️⃣ LinkedHashMap (accessOrder = true) – Your own simple version of LruCache.
Example: Keep last opened chats or last played songs in order.

3️⃣ HashMap + timestamp – Add a “time saved” with each item so it expires after X minutes.
Example: Store weather data for 5 minutes to avoid new network calls.

4️⃣ Network response caching

object RetrofitInstance {

    private const val CACHE_SIZE_BYTES = 10 * 1024 * 1024L // 10 MB
    private const val BASE_URL = HEALTH_TIPS_BASE_URL

    @Volatile
    private var postApi: PostApi? = null

    fun getApi(context: Context): PostApi {
        return postApi ?: synchronized(this) {
            postApi ?: buildRetrofit(context).also { postApi = it }
        }
    }

    private fun buildRetrofit(context: Context): PostApi {
        val cacheDir = File(context.cacheDir, "http_cache")
        val cache = Cache(cacheDir, CACHE_SIZE_BYTES)

        val cacheInterceptor = Interceptor { chain ->
            var request = chain.request()

            if (!NetworkCheckUtils.isConnect(context)) {
                // Offline: allow cache up to 7 days old
                request = request.newBuilder()
                    .header("Cache-Control", "public, only-if-cached, max-stale=604800")
                    .build()
            }

            val response = chain.proceed(request)

            // Online: keep cache for 1 min
            val maxAge = 60 // seconds
            response.newBuilder()
                .header("Cache-Control", "public, max-age=$maxAge")
                .build()
        }

        val loggingInterceptor = HttpLoggingInterceptor().apply {
            level = HttpLoggingInterceptor.Level.BODY
        }

        val okHttpClient = OkHttpClient.Builder()
            .cache(cache)
            .addInterceptor(cacheInterceptor)          // Offline cache
            .addNetworkInterceptor(cacheInterceptor)   // Online cache
            .addInterceptor(loggingInterceptor)
            .connectTimeout(30, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .writeTimeout(30, TimeUnit.SECONDS)
            .build()

        return Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .client(okHttpClient)
            .build()
            .create(PostApi::class.java)
    }
}

- Cache সিস্টেম একই থাকবে — অনলাইনে ১ মিনিট, অফলাইনে ৭ দিন পর্যন্ত ডেটা রাখা হবে।

⦿ পারফরম্যান্স বাড়ে

Offline cache → অ্যাপ সার্ভারে হিট না দিয়ে দ্রুত ডেটা দেখায়।
Online cache → একই ডেটা বারবার ফেচ না করে ক্যাশ থেকে লোড করে (ব্যান্ডউইথ বাঁচে)।
মেমরি ও CPU খরচ কম হবে।
App এর নেটওয়ার্ক পারফরম্যান্স বাড়বে

⦿ ইউজার এক্সপেরিয়েন্স ভালো হয়

ইন্টারনেট স্লো হলেও বা মাঝে মাঝে কানেকশন ড্রপ হলেও ডেটা সঙ্গে সঙ্গে দেখা যাবে।
Offline অবস্থায় ফাঁকা স্ক্রিন বা এরর মেসেজ না দিয়ে শেষবারের ডেটা দেখানো যাবে।

caching-in-android-strategies

caching-process-in-android

Kotlin এর let, apply, also, run

Papon Ahasan — Sat, 05 Jul 2025 18:57:05 +0000

Kotlin এর let, apply, also, run এগুলা এমন কিছু যেগুলা দিয়ে আমরা "কোনো জিনিস" (মানে object) নিয়ে একটু কাজ করি।

ধরো, একটা খেলনা আছে, তুমি সেটা নিয়ে কখন কী করবা, তার ওপর নির্ভর করে তুমি কোনটা ব্যবহার করবা।

১. let – যখন তুমি কোনো কিছু নিয়ে কাজ করে নতুন কিছু বানাতে চাও

📦 ধরো একটা বাক্স (object) আছে, তুমি ওটা খুলে কিছু বের করবা (নতুন ফলাফল পাবে)।

🧒🏻 তুমি বলতেছো: "এই নামটা যদি থাকে আমি এই নামটা নিয়ে একটু কাজ করি, তারপর একটা ফল (length) নিয়ে বের হই।"

val name: String? = "Rakibul"

val length = name?.let {
    println("Name is $it")   // it = "Rakibul"
    it.length                // নতুন কিছু রিটার্ন করলাম: length
}

২. apply – যখন তুমি একটা জিনিসকে সাজাও (configure করো)

🎨 ধরো তুমি একটা পুতুল বানাইছো, এখন তুমি তার জামা, চুল, জুতা পরাও।

🧒🏻 তুমি বলতেছো: "এই পুতুলটা আমার, আমি ওর জামা-জুতা পরিয়ে সাজিয়ে রাখি। আমি কিছু বদলাই, কিন্তু ওটাই থাকুক।"

val person = Person().apply {
    name = "Rakibul"
    age = 25
}

৩. also – যখন তুমি কিছু বলছো বা দেখতেছো, কিন্তু কিছুই বদলাও না

👀 ধরো তুমি একটা খেলনা দেখছো, শুধু "আচ্ছা, এটা এই রকম" বলছো — কিছুই করছো না।

🧒🏻 তুমি বলতেছো: "এই নামটা আছে, আমি দেখে একটু বলে দিলাম। কিন্তু কিছুই বদলাই নাই।"

val name = "Rakibul".also {
    println("Name is: $it")  // শুধু দেখে বললাম
}

৪. run – তুমি কোনো কাজ করবা এবং তার ফল চাও

তুমি বলতেছো, "এই জিনিসটা নিয়ে একটা কাজ শেষ করি, তারপর একটা রেজাল্ট নেই।"

🧒🏻 তুমি বলতেছো: "এই নামটা নিয়ে আমি একটু কাজ করি, তারপর এর length নিয়ে আসি।"

val length = "Rakibul".run {
    println("Running with $this")
    length
}

যদি তুমি Rakibul নামটা একটা খেলনা ভাবো, তাহলে:

let = খেলনা খুলে দেখি ভেতরে কী আছে।
apply = খেলনাটাকে সাজাই।
also = খেলনাটাকে দেখি আর বলি, “আহা, দারুণ!”
run = খেলনাটা দিয়ে একটা খেলা খেলি, তারপর রেজাল্ট নিই।

Process, Thread, Multi-threading, Concurrency

Papon Ahasan — Sat, 17 May 2025 18:07:40 +0000

✅ Process মানে হচ্ছে একটা running program যেটার নিজস্ব memory space থাকে, কিছু data আর resource ধারণ করে, এবং নির্দিষ্ট একটা কাজ করে।

🧠 উদাহরণ:
আমি যদি একসাথে Chrome Browser, VS Code আর Postman চালাই—এগুলো প্রত্যেকটা হচ্ছে আলাদা আলাদা process।

✅ Thread মানে একটা process এর ভেতরে ছোট কাজের unit, যেগুলো একই মেমোরি শেয়ার করে একসাথে আলাদা কাজ করতে পারে।

🧠 উদাহরণ:
Chrome browser-এর প্রতিটা ট্যাব, UI interaction, ভিডিও প্লে—এগুলো প্রত্যেকটা আলাদা thread দিয়ে পরিচালিত হতে পারে।

📌 মোটাদাগে বললে:
Process যদি হয় একটা অ্যাপ, Thread হচ্ছে ঐ অ্যাপের ভেতরের একাধিক রানিং টাস্ক।

✅ Multithreading মানে:
একটা প্রসেস যখন একাধিক থ্রেড তৈরি করে, এবং সেই থ্রেডগুলো একই সময়ে আলাদা কাজ করে।

🧠 উদাহরণ:
একটা অ্যাপে একদিকে ডাটা লোড হচ্ছে, অন্যদিকে ইউজারের ইন্টারঅ্যাকশন হ্যান্ডেল হচ্ছে — এসব একাধিক থ্রেডে হয়ে থাকে।

✅ Concurrency মানে:
একই সময়ে একাধিক কাজ handle করা। যদিও সব কাজ একসাথে (parallel) না হয়ে সময় ভাগ করে চলে।

🧠 উদাহরণ:
আমি রান্না করছি, মাঝে মাঝে ভাত নেড়ে দিচ্ছি, আবার মাঝে মাঝে ডাল ও চেক করছি। এইযে একই সময়ে দুইটা কাজ সামলানো সময় ভাগ করে করে—এটাই concurrency।

সর্বসাকুল্যে বললে,
Process হচ্ছে সম্পূর্ণ আলাদা প্রোগ্রাম, নিজের মেমোরি সহ।
Thread হলো প্রসেসের ভেতরে ছোট ছোট কাজের ইউনিট।
Multithreading হচ্ছে একই প্রসেসে একাধিক থ্রেড একসাথে চালানো, আর
Concurrency হলো একইসাথে একাধিক কাজ সামলানো (parallel না হলেও)

About Concurrency

The following code block does not execute async { ... } blocks one by one. Instead, it executes all of them concurrently(start in parallel, not in sequence): Achieving concurrency using multiple threads.

val results = coroutineScope {
    listOf(
        async { syncWrapper("Keys") { getKeys() } },
        async { syncWrapper("Advertisement") { getAdvertisement() } },
        async { syncWrapper("Company") { getCompany() } },
        async { syncWrapper("Generic") { getGeneric() } },
    ).awaitAll()
}

Each async { ... } block starts running immediately and concurrently within the same coroutineScope.
awaitAll() suspends the current coroutine until all async jobs are finished, and returns their results in a list.

🔥 Benefits of Concurrent Execution (async {} in coroutineScope)

Faster overall time: All sync operations run at the same time, so total duration ≈ longest task, not sum of all tasks.
Efficient use of resources: If your sync logic involves network or disk I/O, concurrent coroutines can improve throughput.
Independent tasks: Like If getKeys(), getAdvertisement(), etc. are not dependent on each other, there’s no reason to wait unnecessarily.

Example: If each task takes 2 seconds:

Sequential = 4 tasks × 2s = 8 seconds.
Concurrent = all in parallel = around 2–3 seconds total.

When to prefer Sequential Execution

You may want to sync one after another only if:

Tasks depend on each other (e.g., you must sync keys before ads).
You want to rate-limit or throttle requests to avoid hitting a server too hard.
You want simple, predictable error handling — easier in sequence sometimes.

💡 Best Practice (Hybrid):

You can use concurrent groups for independent tasks and sequential for dependent ones:

val results = coroutineScope {
    val firstBatch = listOf(
        async { syncWrapper("Keys") { getKeys() } },
        async { syncWrapper("Company") { getCompany() } }
    ).awaitAll()

    val secondBatch = listOf(
        async { syncWrapper("Advertisement") { getAdvertisement() } },
        async { syncWrapper("Generic") { getGeneric() } }
    ).awaitAll()

    firstBatch + secondBatch
}

val results = coroutineScope {
    // Run independent tasks concurrently
    val firstBatch = listOf(
        async { syncWrapper("Keys") { getKeys() } },
        async { syncWrapper("Advertisement") { getAdvertisement() } }
    ).awaitAll()

    // Then run dependent tasks in sequence
    val secondBatch = listOf(
        syncWrapper("Company") { getCompany() },
        syncWrapper("Generic") { getGeneric() }, // depends on Company
        syncWrapper("Product") { getProducts() } // depends on Generic
    )

    firstBatch + secondBatch
}

❗ Potential Problems with Concurrent Sync When Data Depends on Each Other:

Example scenario:

getCompany() must run before getGeneric() because Generic has a company_id foreign key.
If getGeneric() runs before or at the same time as getCompany(), the database may:
- 🔥 Throw a foreign key constraint error, or
- Insert incomplete or orphaned records.

So, 🔁 Sequential Execution

Runs one by one, even for independent tasks, like this: ⏱ Slower overall, because independent tasks wait unnecessarily. ❌ Full Sequential - 5 sec

Keys → Advertisement → Company → Generic → Product → ...

⚡ Mixed (Concurrent + Sequential):
✅ Runs independent tasks together, and only waits where needed:
✅ Faster overall, because you only block where necessary.
✅ Mixed ~3 sec (Keys + Ads run together)

[Keys, Advertisement] → Company → Generic → Product

1. What is the difference between concurrency and multithreading
Answer:

Concurrency is a concept: managing multiple tasks at once.

Multithreading is a technique: achieving concurrency using multiple threads.

2. In Android, why shouldn’t we do heavy tasks on the main thread?

Answer:
The main thread handles UI updates. Doing heavy work (like network/database) blocks it and causes ANR (App Not Responding) errors.

3. What are the advantages of using multiple threads in an app?
Answer:

Better responsiveness (UI thread not blocked)
Faster performance (I/O or network in background threads)
Efficient resource usage

Mastering Android Kotlin: Junior vs Mid vs Senior — Practical Code Examples

Papon Ahasan — Tue, 13 May 2025 17:53:22 +0000

1. Loading Data in a Fragment

Scenario: Load and display user data from a ViewModel.

  lifecycleScope.launchWhenStarted {
      viewModel.userData
          .filterNotNull()
          .collect { user ->
              textView.text = user.name
          }
  }

2. Making a Network Request with Retrofit

Scenario: Fetch user data from an API using Retrofit

  lifecycleScope.launch {
      runCatching { api.getUser() }
          .onSuccess { user ->
              textView.text = user.name
          }
          .onFailure { error ->
              // Handle error
          }
  }

  lifecycleScope.launch {
      runCatching { api.getData() }
          .onSuccess { response ->
              if (response.isSuccessful) {
                  textView.text = response.body()?.data
              } else {
                  showError("Error: ${response.code()}")
              }
          }
          .onFailure {
              showError("Unexpected Error")
          }
  }

3. Handling Button Clicks

Scenario: Respond to a button click event.

  button.setOnClickListener {
      context?.let {
          Toast.makeText(it, "Clicked", Toast.LENGTH_SHORT).show()
      }
  }

4. Navigating Between Fragments

Scenario: Navigate from one fragment to another using Navigation Component.

  val action = FirstFragmentDirections.actionFirstFragmentToSecondFragment()
  findNavController().navigate(action)

5. Displaying a List with RecyclerView

Scenario: Display a list of items using RecyclerView.

  val adapter = MyAdapter().apply {
      submitList(items)
  }
  recyclerView.adapter = adapter

  class MyAdapter : ListAdapter<Item, ItemViewHolder>(ItemDiffCallback()) {
      // ...
  }

  class ItemDiffCallback : DiffUtil.ItemCallback<Item>() {
      override fun areItemsTheSame(oldItem: Item, newItem: Item): Boolean {
          return oldItem.id == newItem.id
      }

      override fun areContentsTheSame(oldItem: Item, newItem: Item): Boolean {
          return oldItem == newItem
      }
  }

  class MyAdapter @Inject constructor() : PagingDataAdapter<Item, MyViewHolder>(DiffCallback()) {
      // Integrates with Paging 3 library
  }

6. Implementing a Search Feature with Debounce

Scenario: Implement a search functionality that waits for the user to stop typing before making a network request.

  // Mid:
  private var searchJob: Job? = null

  searchEditText.addTextChangedListener {
      val query = it.toString()
      searchJob?.cancel()
      searchJob = lifecycleScope.launch {
          delay(300)
          performSearch(query)
      }
  }

// Senior:
  val queryFlow = callbackFlow {
      val watcher = searchEditText.addTextChangedListener {
          trySend(it.toString())
      }
      awaitClose { searchEditText.removeTextChangedListener(watcher) }
  }

  lifecycleScope.launch {
      queryFlow
          .debounce(300)
          .distinctUntilChanged()
          .collect { query ->
              performSearch(query)
          }
  }

  private val _uiState = MutableStateFlow<SearchUiState>(SearchUiState.Idle)
    val uiState: StateFlow<SearchUiState> = _uiState
private val searchDebounce = MutableStateFlow("")
    private fun observeSearch() {
        viewModelScope.launch {
            searchDebounce
                .debounce(300)
                .filter { it.isNotBlank() }
                .distinctUntilChanged()
                .flatMapLatest { query ->
                    flow {
                        emit(SearchUiState.Loading)
                        val results = runCatching { repository.searchDrugs(query) }
                            .getOrElse { throw it }
                        emit(SearchUiState.Success(results))
                    }.catch { e ->
                        emit(SearchUiState.Error(e.message ?: "Unexpected error"))
                    }.flowOn(ioDispatcher)
                }
                .collect { _uiState.value = it }
        }
    }

07. Managing State with ViewModel and LiveData

Scenario: Manage UI state using ViewModel and LiveData.

  // Junior:
  var count = 0

  fun increment() {
      count++
      textView.text = count.toString()
  }

  // Mid:
  class MyViewModel : ViewModel() {
      val count = MutableLiveData<Int>()

      fun increment() {
          val current = count.value ?: 0
          count.value = current + 1
      }
  }

// Senior:
  class MyViewModel : ViewModel() {
      private val _count = MutableStateFlow(0)
      val count: StateFlow<Int> = _count.asStateFlow()

      fun increment() {
          _count.value += 1
      }
  }

08. Requesting Permissions

Scenario: Request location permission at runtime.

class PermissionManager(private val activity: Activity) {
    fun hasPermission(permission: String): Boolean {
        return ContextCompat.checkSelfPermission(activity, permission) == PackageManager.PERMISSION_GRANTED
    }

    fun requestPermissions(vararg permissions: String, requestCode: Int) {
        ActivityCompat.requestPermissions(activity, permissions, requestCode)
    }
}

// Usage
if (!permissionManager.hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)) {
    permissionManager.requestPermissions(Manifest.permission.ACCESS_FINE_LOCATION, LOCATION_REQUEST_CODE)
}

09. Data Storage (SharedPreferences vs DataStore)

Scenario: Store user preference like theme or token.

Switches to DataStore and uses Flow for reactivity

class UserPreferences(context: Context) {
    private val dataStore = context.createDataStore(name = "user_prefs")

    val tokenFlow: Flow<String?> = dataStore.data
        .map { it["token"] }

    suspend fun saveToken(token: String) {
        dataStore.edit {
            it["token"] = token
        }
    }
}

10. Image Loading (with Glide/Coil)

// Mid-level
fun ImageView.loadImage(url: String) {
    Glide.with(this.context)
        .load(url)
        .placeholder(R.drawable.placeholder)
        .error(R.drawable.error)
        .into(this)
}

Reusable component with fallback, caching, and testing
consideration.

// Senior
object ImageLoader {
    fun load(context: Context, imageView: ImageView, url: String) {
        Glide.with(context)
            .load(url)
            .placeholder(R.drawable.placeholder)
            .error(R.drawable.error)
            .diskCacheStrategy(DiskCacheStrategy.ALL)
            .into(imageView)
    }
}

// Usage
ImageLoader.load(context, imageView, url)

DRY-Compliant Approach:

fun Date.toFormattedString(): String {
    val formatter = SimpleDateFormat("dd MMM yyyy", Locale.getDefault())
    return formatter.format(this)
}

DRY-Compliant Approach:

if (text != null && text.isNotEmpty()) {
    // do something
}

fun String?.isNotNullOrEmpty(): Boolean = this != null && this.isNotEmpty()

11. Managing UI Events (e.g., Button Click Debounce)

// Mid-level
button.setOnClickListener(object : View.OnClickListener {
    private var lastClickTime = 0L
    override fun onClick(v: View?) {
        if (System.currentTimeMillis() - lastClickTime < 500) return
        lastClickTime = System.currentTimeMillis()
        // handle click
    }
})

// Senior: Debounce extension function to apply to any View.
fun View.setDebouncedClickListener(delay: Long = 500L, action: () -> Unit) {
    var lastClickTime = 0L
    setOnClickListener {
        val currentTime = System.currentTimeMillis()
        if (currentTime - lastClickTime > delay) {
            lastClickTime = currentTime
            action()
        }
    }
}

// Usage
button.setDebouncedClickListener {
    // handle click
}

12. Handling Null Safety

  val name: String = getName() ?: return
  println(name.length)

13. Using Extension Functions

  fun User.getFullName(): String {
      return "$firstName $lastName"
  }
  // Senior:
  val User.fullName: String
      get() = "$firstName $lastName"

14. Implementing Singleton Pattern

  @Singleton
  class DatabaseHelper @Inject constructor() {
      // Initialization code
  }

15. Using Coroutines for Asynchronous Tasks

Scenario: Fetching data asynchronously.

  // Mid-level:
  lifecycleScope.launch {
      val data = withContext(Dispatchers.IO) { fetchData() }
      updateUI(data)
  }
  // Senior:
  viewModelScope.launch {
      try {
          val data = repository.getData()
          _state.value = UiState.Success(data)
      } catch (e: Exception) {
          _state.value = UiState.Error(e)
      }
  }

16. Using Sealed Classes for UI State

// Mid-level:
enum class UiState { LOADING, SUCCESS, ERROR }

// Senior:
sealed class UiState {
   object Loading : UiState()
   data class Success(val data: Data) : UiState()
   data class Error(val exception: Throwable) : UiState()
}

17. Handling Configuration Changes

Scenario: Preserving data on rotation.

  // Senior:
  // Combine ViewModel with SavedStateHandle

17.

🎓 𝐉𝐮𝐧𝐢𝐨𝐫:

val call = api.getUser()
call.enqueue(object : Callback<User> {
 override fun onResponse(...) { ... }
 override fun onFailure(...) { ... }
})

🧑‍💻 𝐌𝐢𝐝:

lifecycleScope.launch {
 try {
 val user = api.getUser()
 // Update UI
 } catch (e: Exception) {
 // Handle Error
 }
}

🧙 𝐒𝐞𝐧𝐢𝐨𝐫:

val flow = flow { emit(api.getUser()) }
 .flowOn(Dispatchers.IO)
 .catch { handleError(it) }
 .onEach { updateUI(it) }

lifecycleScope.launchWhenStarted { flow.collect() }

18.

🎓 𝐉𝐮𝐧𝐢𝐨𝐫:

    try {
       val result = repository.searchDrugs(query) // Might run on Main Thread ❌
            searchResults.value = result
       } catch (e: Exception) {
                errorMessage.value = e.message
       } finally {
            isLoading.value = false
    }

🧑‍💻 𝐌𝐢𝐝:

   runCatching {
      repository.searchDrugs(query)
         }.onSuccess { results ->
              _uiState.value = SearchUiState.Success(results)
         }.onFailure { e ->
              _uiState.value = SearchUiState.Error(e.message ?: "Unknown error")
         }

🧙 𝐒𝐞𝐧𝐢𝐨𝐫:

       flow {
            emit(SearchUiState.Loading)
                  val results = runCatching { repository.searchDrugs(query) }
                  .getOrElse { throw it }
                        emit(SearchUiState.Success(results))
                   }.catch { e ->
                        emit(SearchUiState.Error(e.message ?: "Unexpected error"))
             }.flowOn(ioDispatcher)

https://halilozel1903.medium.com/mastering-android-kotlin-junior-vs-mid-vs-senior-5-practical-code-examples-073472d4c41a

ABI (Application Binary Interface)

Papon Ahasan — Fri, 02 May 2025 15:26:44 +0000

🎯 Android Developers যারা নিজের অ্যাপ সাইজ কমাতে চান — তারা নিশ্চয়ই "Split APKs by ABI" কথাটা শুনেছেন। কিন্তু ABI (Application Binary Interface) আসলে কী? এবং কেন এটা অ্যাপ সাইজের জন্য গুরুত্বপূর্ণ?

🔍 ABI (Application Binary Interface) হলো একটি চুক্তি (interface) যা Android OS ও ডিভাইসের CPU এর মধ্যে যোগাযোগের নিয়ম নির্ধারণ করে — বিশেষ করে যখন অ্যাপে Native Code (e.g., .so file) থাকে।

📦 ধরুন আপনার অ্যাপে arm64-v8a, armeabi-v7a, x86 — এই সব ABI এর .so ফাইল একসাথে থাকে, তাহলে অ্যাপ সাইজ অনেক বেড়ে যাবে।

🎯 সমাধান?

App Bundle (.aab) ব্যবহার করলে Google Play ইউজারের ডিভাইস অনুযায়ী শুধু সেই ABI-এর অংশ পাঠায়।
অথবা APK দিয়ে নিজে শেয়ার করলে Gradle এ splits.abi enable করে আলাদা APK বানানো যায়।

📸 Slide 1:

আপনার অ্যাপ সাইজ বেশি হয়ে যাচ্ছে?
Native Code (.so ফাইল)?
সমাধান: Split APKs by ABI

📸 Slide 2:

ABI কী?

ABI = Application Binary Interface
Android OS আর ডিভাইসের CPU-এর মধ্যে এক ধরনের "communication agreement"
বিশেষ করে Native কোড রান করার জন্য এটা দরকার হয়

📸 Slide 3:

একসাথে সব ABI দিলে আপনার অ্যাপে একাধিক .so ফাইল থাকে
যেমন: arm64-v8a, armeabi-v7a, x86 — সব মিলিয়ে অ্যাপ সাইজ অনেক বেড়ে যায়

📸 Slide 4:

✅ সমাধান কী?

App Bundle (.aab) ব্যবহার করুন
🔁 Google Play ইউজারের ডিভাইস অনুযায়ী শুধুমাত্র দরকারি ABI পাঠায়

📸 Slide 5:

🎯 আপনি যদি APK ফাইল নিজে শেয়ার করেন:

splits {
   abi {
      enable true
      include 'arm64-v8a', 'armeabi-v7a'
      universalApk false
   }
}

📸 Slide 6:

✅ লাভ কী?

App Size কমে যায়
Faster install & download
Better UX & Performance
এতে অ্যাপ সাইজ কমে, পারফরম্যান্স বাড়ে এবং ইউজার এক্সপেরিয়েন্স হয় উন্নত।

adb devices //see your device listed.
adb install first.apk // install with first APK
adb install -r second.apk // Update with second APK
adb install first.apk && adb install -r second.apk // All in one line

Memory Leaks

Papon Ahasan — Wed, 23 Apr 2025 09:33:40 +0000

🧠 When Can Memory Leaks Happen?

Memory leaks in Android typically happen when an object that holds a reference to a Context (especially Activity) outlives its lifecycle, preventing the system from garbage collecting the Activity.

🧩 Types of Context and When to Use Which

✅ 🚫 Avoid Memory Leaks with These Tips

✅ 1. Use applicationContext when:

You don’t need to access UI
You're working in long-lived classes: e.g., repositories, databases, analytics trackers

val context = context.applicationContext

✅ 2. Avoid Anonymous Inner Classes in Activities

Use static classes or top-level classes to avoid holding implicit references to Activities.

✅ 3. Clear Resources in Lifecycle

Always clear:

Observers (LiveData, BroadcastReceiver)
Coroutine scopes (Job.cancel())
Ad SDKs (nativeAd.destroy())

✅ 4. Don’t Hold Context in Singletons

If you must, store applicationContext, not Activity.

class MySingleton private constructor(private val context: Context) {
    companion object {
        fun init(appContext: Context): MySingleton {
            return MySingleton(appContext.applicationContext)
        }
    }
}

Holding a reference to an Activity or View in a Singleton ❌ Problem:

object MyManager {
    var context: Context? = null // holding activity context
}

📌 Real-World Example:

You create a singleton for analytics or ads that stores an Activity context to show a Toast or dialog — but forget to clear it.

✅ Solution:

Always use context.applicationContext in singletons.

context = context.applicationContext

Inner classes or anonymous classes (e.g. Runnable, Listener) holding implicit reference to outer Activity

❌ Problem:

class MyActivity : AppCompatActivity() {
    private val handler = Handler(Looper.getMainLooper())

    fun start() {
        handler.postDelayed({
            // 'this' refers to Activity, leak if Activity is destroyed
        }, 10000)
    }
}

✅ Solution:

Make the runnable a static class or cancel delayed tasks in onDestroy().

override fun onDestroy() {
    super.onDestroy()
    handler.removeCallbacksAndMessages(null)
}

Long-running background tasks (Coroutines, AsyncTask, Threads) holding context

❌ Problem:

You start a coroutine in a ViewModel or plain class and hold an Activity context.

fun loadData(context: Context) {
    CoroutineScope(Dispatchers.IO).launch {
        // Holding context across configuration change or after activity is gone
        val db = DB.getInstance(context)
    }
}

✅ Solution:

Pass applicationContext if needed.
Cancel coroutine on lifecycle.

fun loadData(appContext: Context) {
    CoroutineScope(Dispatchers.IO).launch {
        val db = DB.getInstance(appContext)
    }
}

LiveData or Flow observing with lifecycle issues

❌ Problem:

You observe LiveData from ViewModel in a Context-based class (like a custom manager), not tied to lifecycle.

viewModel.data.observeForever {
    // Forever means it never stops -> leak
}

✅ Solution:

Always observe with LifecycleOwner (Activity or Fragment) unless you manually remove observers.

viewModel.data.observe(viewLifecycleOwner) { ... }

Dialogs or Toasts shown after Activity is destroyed ❌ Problem:

fun showDialog(context: Context) {
    AlertDialog.Builder(context)
        .setMessage("Hello")
        .show()
}

If context is an Activity and it’s already finishing, the window leaks.
✅ Solution:

Check context:

if (context is Activity && !context.isFinishing) {
    AlertDialog.Builder(context)
        .setMessage("Safe")
        .show()
}

Static Views or holding binding in fragments after view is destroyed ❌ Problem:

class MyFragment : Fragment() {
    private lateinit var binding: FragmentMyBinding

    override fun onDestroyView() {
        super.onDestroyView()
        // Forget to clear binding -> view leak
    }
}

✅ Solution:

Clear binding in onDestroyView():

override fun onDestroyView() {
    super.onDestroyView()
    _binding = null
}

Custom callbacks or listeners not removed ❌ Problem:

someView.setOnClickListener {
    // Holds reference to outer Activity
}

If the view lives longer (e.g., part of an SDK), it keeps the activity alive.
✅ Solution:

Remove listeners:

override fun onDestroy() {
    someView.setOnClickListener(null)
}

class MySingleton private constructor(private val context: Context) {

    companion object {
        @Volatile
        private var INSTANCE: MySingleton? = null

        fun getInstance(appContext: Context): MySingleton {
            return INSTANCE ?: synchronized(this) {
                INSTANCE ?: MySingleton(appContext.applicationContext).also { INSTANCE = it }
            }
        }
    }

    // Example usage of application context
    fun doSomethingGlobal() {
        Toast.makeText(context, "Doing something!", Toast.LENGTH_SHORT).show()
    }
}

private var weakActivity: WeakReference<Activity>? = null

fun bindActivity(activity: Activity) {
    weakActivity = WeakReference(activity)
}

fun doSomething() {
    val activity = weakActivity?.get() ?: return
    // Use it safely
}

❌ Problem: 🔴 Without Job — সমস্যা:

👉 যদি user ৪ সেকেন্ডের মধ্যে বারবার call করে, সব coroutine queue তে ঢুকে যাবে → multiple popups → 😵 UI bug!

lifecycleScope.launch {
    delay(4000)
    getDrugDetailPopupImage(genericId)
}

🟢 With Job — Smart & Controlled: 👉 একবারে শুধুমাত্র একটা popup চলবে। নতুন কাজ এলে পুরনোটা কেটে যাবে।

private var popupJob: Job? = null

popupJob?.cancel() // পুরনো চলমান coroutine বন্ধ
popupJob = lifecycleScope.launch {
    delay(4000)
    getDrugDetailPopupImage(genericId)
}

📌 এর উদ্দেশ্য:

আগের popup coroutine চলমান থাকলে তা cancel করে ফেলা
নতুন coroutine দিয়ে popup image delayed show করা
একই সময় একটির বেশি popup না দেখানো
🧠 Memory leak রোধ না চাইতেও চলতে থাকা coroutine বন্ধ করে দে

মেমোরি লিক কী?

মেমোরি লিক তখন হয়, যখন আপনার অ্যাপের অবজেক্টগুলো গারবেজ কালেক্টর (Garbage Collector) রিমুভ করতে পারে না, কারণ এখনও কেউ সেই অবজেক্টের রেফারেন্স ধরে রেখেছে — যদিও সেই অবজেক্ট দরকার নেই। ফলে অ্যাপের RAM ব্যবহার বাড়ে, পারফরম্যান্স কমে, এমনকি অ্যাপ ক্র্যাশও করতে পারে।

LeakCanary হল Square কোম্পানির বানানো একটা open-source Android library যা মেমোরি লিক অটো ডিটেক্ট করতে পারে ডেভেলপমেন্ট বিল্ডে।

// build.gradle (app)
dependencies {
    debugImplementation "com.squareup.leakcanary:leakcanary-android:2.13"
}

Leak Report দেখতে কেমন হয়?

// ➡️ এই report বলছে MyActivity destroy হওয়ার পরেও mContext রেফারেন্সে থাকার কারণে release হয়নি।
ActivityLeakActivity has leaked:
↳ xyz.MyActivity instance
   |   mContext → xyz.MyActivity
   |   mDestroyed → true

Tip1: Leak Canary Debug Log:

D LeakCanary: Watching instance of xyz.MyActivity (Activity) with key XYZ123...

┬
├─ com.example.MyActivity
│    Leaking: YES
│    Retaining 1.2 MB in 10060 bytes
│    ↓ MyActivity.someStaticReference
│                        ~~~~~~~~~~~~~
├─ android.widget.SomeView
│    ↓ View.mContext
│               ~~~~~~~~
...

- MyFragment.binding null করা হয়নি, তাই View এর মধ্যে থাকা context (Activity) leak হয়েছে।

✅ সমাধান: onDestroyView() এ binding = null করে দিন।

┬
├─ MyFragment
│    Leaking: YES
│    ↓ MyFragment.binding
│                 ~~~~~~~
├─ MyFragmentBinding
│    ↓ binding.textView
│              ~~~~~~~~
├─ TextView
│    ↓ View.mContext
│              ~~~~~~~

প্রতিটি লাইন দেখুন যেটাতে ↓ (down arrow) আছে, LeakCanary এই arrows দিয়ে বোঝায় কার মাধ্যমে রেফারেন্স ধরে আছে:

StrictMode.setThreadPolicy(
    StrictMode.ThreadPolicy.Builder()
        .detectDiskReads()      // ডিস্ক থেকে ডাটা পড়া হলে সতর্ক করবে
        .detectDiskWrites()     // ডিস্কে লেখা হলে সতর্ক করবে
        .detectNetwork()        // নেটওয়ার্ক কল হলে সতর্ক করবে
        .penaltyLog()           // এসব ঘটনার সময় লগ করবে
        .build()
)

StrictMode.setVmPolicy(
    StrictMode.VmPolicy.Builder()
        .detectLeakedSqlLiteObjects()    // যেসব Sqlite অবজেক্ট বন্ধ হয়নি, সেগুলো চিনবে
        .detectLeakedClosableObjects()   // যেসব ক্লোজেবল অবজেক্ট (যেমন ফাইল, স্ট্রীম) বন্ধ হয়নি সেগুলো চিনবে
        .penaltyLog()                    // এসব ইস্যু হলে লগ করবে
        .build()
)

- মেইন থ্রেডে ডিস্ক বা নেটওয়ার্ক অপারেশন হলে তোমাকে জানাবে

- যেসব ডেটাবেস বা ফাইল রিসোর্স তুমি ভুলে বন্ধ করো নি, সেগুলোও ধরবে

- সবই লগ করে ডেভেলপারকে ইস্যু সম্পর্কে সচেতন করবে

কেন দরকার?
অ্যাপ ঠিকঠাক এবং দ্রুত কাজ করুক আর ইউজার ভালো অভিজ্ঞতা পায়, সেজন্য যেসব কাজ মেইন থ্রেড ব্লক করে সেগুলো খুঁজে বের করা খুব জরুরি। StrictMode সেই কাজে সাহায্য করে।

Android Scheduled Notification

Papon Ahasan — Thu, 12 Sep 2024 00:58:28 +0000

data class NotificationModel(
    var id: String,
    var titleEng: String,
    var titleBng: String?,
    var bodyEng: String,
    var bodyBng: String?,
    var link: String?,
    var button: String?,
    var image: String?,
)

val listOfAlarm = listOf(
    NotificationModel(
        id = "1",
        titleEng = "পরিবারের সকল সদস্যের নামে ঔষধ বুকমার্ক করুন।\n",
        titleBng = "পরিবারের সকল সদস্যের নামে ঔষধ বুকমার্ক করুন।\n",
        bodyEng = "পেশেন্ট এইড দিচ্ছে মাল্টি (একাধিক) প্রোফাইল তৈরি করার সুবিধা। পরিবারের সদস্যদের ঔষধ বুকমার্ক করে রাখুন তাদের নিজেদের নামে। সুবিধাটি রয়েছে শুধু প্রিমিয়াম ব্যবহার কারিদের জন্য। তাই দেরি না করে এখনি কিনে নিন।",
        bodyBng = "পেশেন্ট এইড দিচ্ছে মাল্টি (একাধিক) প্রোফাইল তৈরি করার সুবিধা। পরিবারের সদস্যদের ঔষধ বুকমার্ক করে রাখুন তাদের নিজেদের নামে। সুবিধাটি রয়েছে শুধু প্রিমিয়াম ব্যবহার কারিদের জন্য। তাই দেরি না করে এখনি কিনে নিন।",
        link = "",
        button = "",
        image = "",
    )
}

    private fun periodicScheduleNotificationWorker() {
        val workRequest =
            PeriodicWorkRequestBuilder<ScheduledNotificationManager>(15, TimeUnit.MINUTES)
                // Additional configuration
                .addTag("SN2")
                .build()

        WorkManager.getInstance(this)
            .enqueueUniquePeriodicWork(
                ScheduledNotificationManager.TAG,
                ExistingPeriodicWorkPolicy.KEEP,
                workRequest
            )
        Log.d("tag", "Periodic Scheduled Notification Worker Launched2")
    }

class UserActivityTracker(context: Context) {
    fun saveLastMessageIndex(index: Int) {
        sharedPreferences.edit().putInt("last_message_index", index).apply()
    }

    fun getLastMessageIndex(): Int {
        return sharedPreferences.getInt("last_message_index", 0)
    }

    fun setLastActivity() {
        val currentTime = System.currentTimeMillis()
        sharedPreferences.edit().putLong("last_activity_timestamp", currentTime).apply()
    }

    private fun getLastActivityTime(): Long {
        return sharedPreferences.getLong("last_activity_timestamp", 0L)
    }

    fun isInActiveInLastFiveDays(): Boolean {
        val currentTime = System.currentTimeMillis()
        val fiveDaysInMillis = Constants.INTERVAL_5_DAYS // 5 days in milliseconds 
        val lastActivityTimestamp = getLastActivityTime()
        val isActiveInLastFiveDays = currentTime - lastActivityTimestamp >= fiveDaysInMillis
        return isActiveInLastFiveDays
    }
}

class ScheduledNotificationManager(
    appContext: Context, params: WorkerParameters,
) : CoroutineWorker(appContext, params) {

    companion object {
        const val TAG = "ScheduledNotificationManager"
    }

    override suspend fun doWork(): Result {
        try {
            val tracker = UserActivityTracker(applicationContext)
            val lastMessageIndex = tracker.getLastMessageIndex()

            if (tracker.isInActiveInLastFiveDays()) {
                // User has not been active in the last 5 days
                Log.d(TAG, "User is not active in the last 5 days.")
                val notifyUtil = PeriodicNotificationUtil()
                val notifyManager =
                    applicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
                notifyUtil.sendNotification(applicationContext, listOfAlarm[lastMessageIndex], notifyManager)

                if (lastMessageIndex == listOfAlarm.size - 1) {
                    tracker.saveLastMessageIndex(0)
                } else {
                    tracker.saveLastMessageIndex(lastMessageIndex + 1)
                }
            } else {
                // User has been active in the last 5 days
                Log.d(TAG, "UserStatus: User is active in the last 5 days.")
            }

        } catch (e: Exception) {
            e.printStackTrace()
        }


        return Result.success()
    }
}

Android Carousel Image Slider With Material Design

Papon Ahasan — Wed, 11 Sep 2024 22:59:57 +0000

Dependency

implementation 'com.google.android.material:material:1.9.0'
implementation 'com.github.chrisbanes:PhotoView:2.1.3'

Activity Layout

  <androidx.recyclerview.widget.RecyclerView
       android:id="@+id/carousel_recycler_view"    
app:layoutManager="com.google.android.material.carousel.CarouselLayoutManager"
       android:layout_width="match_parent"
       tools:listitem="@layout/carousel_layout"
                    android:background="@drawable/rounded_corners"
      android:layout_height="140dp"
      android:layout_gravity="center"
      android:clipChildren="false"
      android:clipToPadding="false" />

carousel_layout.xml

<com.google.android.material.carousel.MaskableFrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/carousel_item_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_marginStart="@dimen/_5sdp"
    android:layout_marginTop="@dimen/_5sdp"
    android:layout_marginEnd="@dimen/_5sdp"
    android:layout_marginBottom="@dimen/_5sdp"
    android:foreground="?attr/selectableItemBackground"
    app:shapeAppearance="?attr/shapeAppearanceCornerExtraLarge">

    <androidx.constraintlayout.widget.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <com.github.chrisbanes.photoview.PhotoView
            android:id="@+id/carousel_image_view"
            android:layout_width="0dp"
            android:layout_height="0dp"
            android:contentDescription="TODO"
            android:scaleType="centerCrop"
            android:src="@drawable/new_bannerr"
            android:clipToOutline="true"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toTopOf="parent" />

        <ImageView
            android:id="@+id/close_btn"
            android:layout_width="@dimen/_30sdp"
            android:layout_height="@dimen/_30sdp"
            android:layout_marginEnd="10dp"
            android:contentDescription="TODO"
            android:padding="8dp"
            android:src="@drawable/close_for_edit_text"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintTop_toTopOf="@+id/carousel_image_view"
            app:tint="@color/color_red" />

    </androidx.constraintlayout.widget.ConstraintLayout>

</com.google.android.material.carousel.MaskableFrameLayout>

CarouselAdapter

class CarouselAdapter(
    private val imageList: ArrayList<Uri>,
    val context: Context,
    private val onListEmptyCallback: () -> Unit
) :
    RecyclerView.Adapter<CarouselAdapter.ItemViewHolder>() {

    inner class ItemViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        val imageView: PhotoView = itemView.findViewById(R.id.carousel_image_view)
        val carouselItemCounter: MaskableFrameLayout =
            itemView.findViewById(R.id.carousel_item_container)
        val deleteButton: ImageView = itemView.findViewById(R.id.close_btn)
    }

    override fun onCreateViewHolder(
        parent: ViewGroup,
        viewType: Int
    ): CarouselAdapter.ItemViewHolder {
        val view =
            LayoutInflater.from(parent.context).inflate(R.layout.carousel_layout, parent, false)
        return ItemViewHolder(view)
    }

    @SuppressLint("RestrictedApi")
    override fun onBindViewHolder(holder: CarouselAdapter.ItemViewHolder, position: Int) {
        holder.imageView.load(imageList[position])

        holder.carouselItemCounter.setOnMaskChangedListener { maskRect ->
            // Any custom motion to run when mask size changes
            holder.deleteButton.translationX = maskRect.left
            holder.deleteButton.setAlpha(lerp(1F, 0F, 0F, 80F, maskRect.left))
        }

        // Handle delete button click
        holder.deleteButton.setOnClickListener {
            removeImage(position)
        }

        // Initialize the adapter with the image click callback
        holder.imageView.setOnClickListener {
            showImagePopup(imageList[position])
        }
    }

    // Function to remove the image from the list
    private fun removeImage(position: Int) {
        imageList.removeAt(position)
        notifyItemRemoved(position)
        notifyItemRangeChanged(position, imageList.size)  // Update adapter to refresh the layout
        // Check if list is empty and trigger the callback
        if (imageList.isEmpty()) {
            onListEmptyCallback.invoke()
        }
    }

    // Function to show the image in a popup dialog
    private fun showImagePopup(imageUri: Uri) {
        // Create an ImageView dynamically
        val imageView = PhotoView(context)
        imageView.setImageURI(imageUri)
        imageView.adjustViewBounds = true // Allow scaling of the image

        // Create an AlertDialog to show the image
        val dialog = AlertDialog.Builder(context)
            .setView(imageView)
            .setPositiveButton("Close") { dialog, _ ->
                dialog.dismiss()
            }
            .create()

        // Show the dialog
        dialog.show()
        dialog.window?.setDimAmount(0.5f)

    }

    override fun getItemCount() = imageList.size
}

Activity

private val imageList = ArrayList<Uri>()
private val carouselAdapter = CarouselAdapter(imageList, this) {
   updateAdapter()
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_medical_record)

   setupRecyclerView()
   updateAdapter()
}

private fun setupRecyclerView() {
     carouselRecyclerView = findViewById(R.id.carousel_recycler_view)
carouselRecyclerView.setLayoutManager(CarouselLayoutManager())
    carouselRecyclerView.adapter = carouselAdapter
    // Initially show the empty view if the list is empty
     if (imageList.isEmpty()) {
            carouselRecyclerView.visibility = View.GONE
        } else {
            carouselRecyclerView.visibility = View.VISIBLE
        }
    }

private fun updateAdapter() {
    carouselRecyclerView.visibility = View.VISIBLE
    carouselAdapter.notifyDataSetChanged()
    // the empty view if the list is empty
    if (imageList.isEmpty()) {
       carouselRecyclerView.visibility = View.GONE
    } else {
       carouselRecyclerView.visibility = View.VISIBLE
     }
 }

Get API Map Key

Papon Ahasan — Sun, 09 Jul 2023 02:23:22 +0000

Youtube

https://developers.google.com/maps/documentation/android-sdk/overview