Merge remote-tracking branch 'refs/remotes/root/develop' into SAML_SSO

# Conflicts:
#	core/src/main/java/org/openedx/core/config/Config.kt

Author: RawanMatar89

app/build.gradle

@@ -125,6 +125,7 @@ dependencies {
     implementation project(path: ':profile')
     implementation project(path: ':discussion')
     implementation project(path: ':whatsnew')
+    implementation project(path: ':downloads')
 
     ksp "androidx.room:room-compiler:$room_version"
 

app/src/main/java/org/openedx/app/AnalyticsManager.kt

@@ -2,6 +2,7 @@ package org.openedx.app
 
 import org.openedx.auth.presentation.AuthAnalytics
 import org.openedx.core.presentation.CoreAnalytics
+import org.openedx.core.presentation.DownloadsAnalytics
 import org.openedx.core.presentation.dialog.appreview.AppReviewAnalytics
 import org.openedx.course.presentation.CourseAnalytics
 import org.openedx.dashboard.presentation.DashboardAnalytics
@@ -21,7 +22,8 @@ class AnalyticsManager :
     DiscoveryAnalytics,
     DiscussionAnalytics,
     ProfileAnalytics,
-    WhatsNewAnalytics {
+    WhatsNewAnalytics,
+    DownloadsAnalytics {
 
     private val analytics: MutableList<Analytics> = mutableListOf()
 

app/src/main/java/org/openedx/app/AppActivity.kt

@@ -27,11 +27,11 @@ import org.openedx.auth.presentation.logistration.LogistrationFragment
 import org.openedx.auth.presentation.signin.SignInFragment
 import org.openedx.core.ApiConstants
 import org.openedx.core.data.storage.CorePreferences
+import org.openedx.core.presentation.dialog.downloaddialog.DownloadDialogManager
 import org.openedx.core.presentation.global.InsetHolder
 import org.openedx.core.presentation.global.WindowSizeHolder
 import org.openedx.core.utils.Logger
 import org.openedx.core.worker.CalendarSyncScheduler
-import org.openedx.course.presentation.download.DownloadDialogManager
 import org.openedx.foundation.extension.requestApplyInsetsWhenAttached
 import org.openedx.foundation.presentation.WindowSize
 import org.openedx.foundation.presentation.WindowType

app/src/main/java/org/openedx/app/AppAnalytics.kt

@@ -20,6 +20,10 @@ enum class AppAnalyticsEvent(val eventName: String, val biValue: String) {
         "MainDashboard:Discover",
         "edx.bi.app.main_dashboard.discover"
     ),
+    DOWNLOADS(
+        "MainDashboard:Downloads",
+        "edx.bi.app.main_dashboard.downloads"
+    ),
     PROFILE(
         "MainDashboard:Profile",
         "edx.bi.app.main_dashboard.profile"

app/src/main/java/org/openedx/app/AppRouter.kt

@@ -45,6 +45,7 @@ import org.openedx.discussion.presentation.responses.DiscussionResponsesFragment
 import org.openedx.discussion.presentation.search.DiscussionSearchThreadFragment
 import org.openedx.discussion.presentation.threads.DiscussionAddThreadFragment
 import org.openedx.discussion.presentation.threads.DiscussionThreadsFragment
+import org.openedx.downloads.presentation.DownloadsRouter
 import org.openedx.profile.domain.model.Account
 import org.openedx.profile.presentation.ProfileRouter
 import org.openedx.profile.presentation.anothersaccount.AnothersProfileFragment
@@ -68,7 +69,8 @@ class AppRouter :
     ProfileRouter,
     AppUpgradeRouter,
     WhatsNewRouter,
-    CalendarRouter {
+    CalendarRouter,
+    DownloadsRouter {
 
     // region AuthRouter
     override fun navigateToMain(

app/src/main/java/org/openedx/app/MainFragment.kt

@@ -1,7 +1,13 @@
 package org.openedx.app
 
 import android.os.Bundle
+import android.view.Menu
 import android.view.View
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.livedata.observeAsState
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
 import androidx.core.os.bundleOf
 import androidx.core.view.forEach
 import androidx.fragment.app.Fragment
@@ -13,10 +19,16 @@ import org.koin.android.ext.android.inject
 import org.koin.androidx.viewmodel.ext.android.viewModel
 import org.openedx.app.databinding.FragmentMainBinding
 import org.openedx.app.deeplink.HomeTab
+import org.openedx.core.AppUpdateState
+import org.openedx.core.AppUpdateState.wasUpgradeDialogClosed
 import org.openedx.core.adapter.NavigationFragmentAdapter
+import org.openedx.core.presentation.dialog.appupgrade.AppUpgradeDialogFragment
+import org.openedx.core.presentation.global.appupgrade.AppUpgradeRecommendedBox
 import org.openedx.core.presentation.global.appupgrade.UpgradeRequiredFragment
 import org.openedx.core.presentation.global.viewBinding
+import org.openedx.core.system.notifier.app.AppUpgradeEvent
 import org.openedx.discovery.presentation.DiscoveryRouter
+import org.openedx.downloads.presentation.download.DownloadsFragment
 import org.openedx.learn.presentation.LearnFragment
 import org.openedx.learn.presentation.LearnTab
 import org.openedx.profile.presentation.profile.ProfileFragment
@@ -40,29 +52,105 @@ class MainFragment : Fragment(R.layout.fragment_main) {
 
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
+        handleArguments()
+        setupBottomNavigation()
+        setupViewPager()
+        setupBottomPopup()
+        observeViewModel()
+    }
 
-        initViewPager()
-
-        binding.bottomNavView.setOnItemSelectedListener {
-            when (it.itemId) {
-                R.id.fragmentLearn -> {
-                    viewModel.logLearnTabClickedEvent()
-                    binding.viewPager.setCurrentItem(0, false)
+    private fun handleArguments() {
+        requireArguments().apply {
+            getString(ARG_COURSE_ID).takeIf { it.isNullOrBlank().not() }?.let { courseId ->
+                val infoType = getString(ARG_INFO_TYPE)
+                if (viewModel.isDiscoveryTypeWebView && infoType != null) {
+                    router.navigateToCourseInfo(parentFragmentManager, courseId, infoType)
+                } else {
+                    router.navigateToCourseDetail(parentFragmentManager, courseId)
                 }
+                putString(ARG_COURSE_ID, "")
+                putString(ARG_INFO_TYPE, "")
+            }
+        }
+    }
 
-                R.id.fragmentDiscover -> {
-                    viewModel.logDiscoveryTabClickedEvent()
-                    binding.viewPager.setCurrentItem(1, false)
-                }
+    private fun setupBottomNavigation() {
+        val openTabArg = requireArguments().getString(ARG_OPEN_TAB, HomeTab.LEARN.name)
+        val initialMenuId = getInitialMenuId(openTabArg)
+        binding.bottomNavView.selectedItemId = initialMenuId
 
-                R.id.fragmentProfile -> {
-                    viewModel.logProfileTabClickedEvent()
-                    binding.viewPager.setCurrentItem(2, false)
-                }
+        val menu = binding.bottomNavView.menu
+        menu.clear()
+
+        val tabList = createTabList(openTabArg)
+        addMenuItems(menu, tabList)
+        setupBottomNavListener(tabList)
+
+        requireArguments().remove(ARG_OPEN_TAB)
+    }
+
+    private fun createTabList(openTabArg: String): List<Pair<Int, Fragment>> {
+        val learnFragment = LearnFragment.newInstance(
+            openTab = if (openTabArg == HomeTab.PROGRAMS.name) {
+                LearnTab.PROGRAMS.name
+            } else {
+                LearnTab.COURSES.name
+            }
+        )
+
+        return mutableListOf<Pair<Int, Fragment>>().apply {
+            add(R.id.fragmentLearn to learnFragment)
+            add(R.id.fragmentDiscover to viewModel.getDiscoveryFragment)
+            if (viewModel.isDownloadsFragmentEnabled) {
+                add(R.id.fragmentDownloads to DownloadsFragment())
+            }
+            add(R.id.fragmentProfile to ProfileFragment())
+        }
+    }
+
+    private fun addMenuItems(menu: Menu, tabList: List<Pair<Int, Fragment>>) {
+        val tabTitles = mapOf(
+            R.id.fragmentLearn to resources.getString(R.string.app_navigation_learn),
+            R.id.fragmentDiscover to resources.getString(R.string.app_navigation_discovery),
+            R.id.fragmentDownloads to resources.getString(R.string.app_navigation_downloads),
+            R.id.fragmentProfile to resources.getString(R.string.app_navigation_profile),
+        )
+        val tabIconSelectors = mapOf(
+            R.id.fragmentLearn to R.drawable.app_ic_learn_selector,
+            R.id.fragmentDiscover to R.drawable.app_ic_discover_selector,
+            R.id.fragmentDownloads to R.drawable.app_ic_downloads_selector,
+            R.id.fragmentProfile to R.drawable.app_ic_profile_selector
+        )
+
+        for ((id, _) in tabList) {
+            val menuItem = menu.add(Menu.NONE, id, Menu.NONE, tabTitles[id] ?: "")
+            tabIconSelectors[id]?.let { menuItem.setIcon(it) }
+        }
+    }
+
+    private fun setupBottomNavListener(tabList: List<Pair<Int, Fragment>>) {
+        val menuIdToIndex = tabList.mapIndexed { index, pair -> pair.first to index }.toMap()
+
+        binding.bottomNavView.setOnItemSelectedListener { menuItem ->
+            when (menuItem.itemId) {
+                R.id.fragmentLearn -> viewModel.logLearnTabClickedEvent()
+                R.id.fragmentDiscover -> viewModel.logDiscoveryTabClickedEvent()
+                R.id.fragmentDownloads -> viewModel.logDownloadsTabClickedEvent()
+                R.id.fragmentProfile -> viewModel.logProfileTabClickedEvent()
+            }
+            menuIdToIndex[menuItem.itemId]?.let { index ->
+                binding.viewPager.setCurrentItem(index, false)
             }
             true
         }
+    }
+
+    private fun setupViewPager() {
+        val tabList = createTabList(requireArguments().getString(ARG_OPEN_TAB, HomeTab.LEARN.name))
+        initViewPager(tabList)
+    }
 
+    private fun observeViewModel() {
         viewModel.isBottomBarEnabled.observe(viewLifecycleOwner) { isBottomBarEnabled ->
             enableBottomBar(isBottomBarEnabled)
         }
@@ -74,55 +162,30 @@ class MainFragment : Fragment(R.layout.fragment_main) {
                 }
             }
         }
+    }
 
-        requireArguments().apply {
-            getString(ARG_COURSE_ID).takeIf { it.isNullOrBlank().not() }?.let { courseId ->
-                val infoType = getString(ARG_INFO_TYPE)
-
-                if (viewModel.isDiscoveryTypeWebView && infoType != null) {
-                    router.navigateToCourseInfo(parentFragmentManager, courseId, infoType)
-                } else {
-                    router.navigateToCourseDetail(parentFragmentManager, courseId)
-                }
-
-                // Clear arguments after navigation
-                putString(ARG_COURSE_ID, "")
-                putString(ARG_INFO_TYPE, "")
-            }
-
-            when (requireArguments().getString(ARG_OPEN_TAB, "")) {
-                HomeTab.LEARN.name,
-                HomeTab.PROGRAMS.name -> {
-                    binding.bottomNavView.selectedItemId = R.id.fragmentLearn
-                }
-
-                HomeTab.DISCOVER.name -> {
-                    binding.bottomNavView.selectedItemId = R.id.fragmentDiscover
-                }
-
-                HomeTab.PROFILE.name -> {
-                    binding.bottomNavView.selectedItemId = R.id.fragmentProfile
-                }
+    private fun getInitialMenuId(openTabArg: String): Int {
+        return when (openTabArg) {
+            HomeTab.LEARN.name, HomeTab.PROGRAMS.name -> R.id.fragmentLearn
+            HomeTab.DISCOVER.name -> R.id.fragmentDiscover
+            HomeTab.DOWNLOADS.name -> if (viewModel.isDownloadsFragmentEnabled) {
+                R.id.fragmentDownloads
+            } else {
+                R.id.fragmentLearn
             }
-            requireArguments().remove(ARG_OPEN_TAB)
+            HomeTab.PROFILE.name -> R.id.fragmentProfile
+            else -> R.id.fragmentLearn
         }
     }
 
-    @Suppress("MagicNumber")
-    private fun initViewPager() {
+    private fun initViewPager(tabList: List<Pair<Int, Fragment>>) {
         binding.viewPager.orientation = ViewPager2.ORIENTATION_HORIZONTAL
-        binding.viewPager.offscreenPageLimit = 4
+        binding.viewPager.offscreenPageLimit = tabList.size
 
-        val openTab = requireArguments().getString(ARG_OPEN_TAB, HomeTab.LEARN.name)
-        val learnTab = if (openTab == HomeTab.PROGRAMS.name) {
-            LearnTab.PROGRAMS
-        } else {
-            LearnTab.COURSES
-        }
         adapter = NavigationFragmentAdapter(this).apply {
-            addFragment(LearnFragment.newInstance(openTab = learnTab.name))
-            addFragment(viewModel.getDiscoveryFragment)
-            addFragment(ProfileFragment())
+            tabList.forEach { (_, fragment) ->
+                addFragment(fragment)
+            }
         }
         binding.viewPager.adapter = adapter
         binding.viewPager.isUserInputEnabled = false
@@ -134,6 +197,56 @@ class MainFragment : Fragment(R.layout.fragment_main) {
         }
     }
 
+    private fun setupBottomPopup() {
+        binding.composeBottomPopup.setContent {
+            val appUpgradeEvent by viewModel.appUpgradeEvent.observeAsState()
+            val wasUpgradeDialogClosed by remember { wasUpgradeDialogClosed }
+            val appUpgradeParameters = AppUpdateState.AppUpgradeParameters(
+                appUpgradeEvent = appUpgradeEvent,
+                wasUpgradeDialogClosed = wasUpgradeDialogClosed,
+                appUpgradeRecommendedDialog = {
+                    val dialog = AppUpgradeDialogFragment.newInstance()
+                    dialog.show(
+                        requireActivity().supportFragmentManager,
+                        AppUpgradeDialogFragment::class.simpleName
+                    )
+                },
+                onAppUpgradeRecommendedBoxClick = {
+                    AppUpdateState.openPlayMarket(requireContext())
+                },
+                onAppUpgradeRequired = {
+                    router.navigateToUpgradeRequired(
+                        requireActivity().supportFragmentManager
+                    )
+                }
+            )
+            when (appUpgradeParameters.appUpgradeEvent) {
+                is AppUpgradeEvent.UpgradeRecommendedEvent -> {
+                    if (appUpgradeParameters.wasUpgradeDialogClosed) {
+                        AppUpgradeRecommendedBox(
+                            modifier = Modifier.fillMaxWidth(),
+                            onClick = appUpgradeParameters.onAppUpgradeRecommendedBoxClick
+                        )
+                    } else {
+                        if (!AppUpdateState.wasUpdateDialogDisplayed) {
+                            AppUpdateState.wasUpdateDialogDisplayed = true
+                            appUpgradeParameters.appUpgradeRecommendedDialog()
+                        }
+                    }
+                }
+
+                is AppUpgradeEvent.UpgradeRequiredEvent -> {
+                    if (!AppUpdateState.wasUpdateDialogDisplayed) {
+                        AppUpdateState.wasUpdateDialogDisplayed = true
+                        appUpgradeParameters.onAppUpgradeRequired()
+                    }
+                }
+
+                else -> {}
+            }
+        }
+    }
+
     companion object {
         private const val ARG_COURSE_ID = "courseId"
         private const val ARG_INFO_TYPE = "info_type"