AndroidCareProvider - Structure Analysis¶

┌──────────────────────────────────────────────────────────────┐
│                   External Systems                            │
├──────────────────────────────────────────────────────────────┤
│  • Firebase (FCM, Crashlytics, Auth)                         │
│  • PsyterAPI (REST Backend)                                  │
│  • NodeServer (WebSocket)                                    │
│  • VideoSDK (Video Calls)                                    │
│  • Payment Gateway (Web redirect)                             │
│  • MediaAPI (File uploads)                                   │
└──────────────────────────────────────────────────────────────┘
                           ↑
                           │ HTTPS/WSS/FCM
                           ↓
┌──────────────────────────────────────────────────────────────┐
│           AndroidCareProvider Application                     │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │ Presentation │  │  Navigation  │  │   Workers    │      │
│  │   Layer      │  │  (Jetpack)   │  │ (WorkManager)│      │
│  │ Activities/  │  │              │  │              │      │
│  │  Fragments   │  │  TabManager  │  │ Background   │      │
│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘      │
│         │                 │                 │              │
│  ┌──────▼─────────────────▼─────────────────▼───────┐      │
│  │         Business Logic Layer                      │      │
│  │  • Adapters (RecyclerView)                       │      │
│  │  • DataModels (DTOs)                             │      │
│  │  • Event Bus (MessageObservable)                 │      │
│  └──────────────────┬────────────────────────────────┘      │
│                     │                                        │
│  ┌──────────────────▼────────────────────────────────┐      │
│  │         Network & Data Layer                      │      │
│  │  • Fast Android Networking                        │      │
│  │  • WebSocket (nv-websocket-client)               │      │
│  │  • SharedPreferences                              │      │
│  │  • Glide (Image caching)                          │      │
│  └───────────────────────────────────────────────────┘      │
│                                                              │
└──────────────────────────────────────────────────────────────┘

App Launch
    ↓
SplashActivity
    ↓
Check Auth Status (SharedPreferences)
    ↓
    ├─→ [Logged Out] → LoginActivity → UserSelectionActivity → RegisterCareProviderActivity
    │                                                                    ↓
    └─→ [Logged In] ──────────────────────────────────────→ BaseClientActivityMain
                                                                         ↓
                                                            [Bottom Navigation - 5 Tabs]
                                                                         ↓
                            ┌────────────────────────┬────────────────────────┬───────────────┬───────────────┐
                            ↓                        ↓                        ↓               ↓               ↓
                        HomeFragment        AppointmentsFragment    MyQyestionaireFragment  HomeworksFragment  MoreTabFragment
                                                    ↓
                                        OneToOneCallActivity (Video SDK)
                                        ChatMainActivity (Messaging)
                                        ClientHistoryActivity (Patient History)

com.psyter.www/
├── MainApplication.java              # Application entry point
├── MyFirebaseMessagingService.java   # FCM push notification handler
├── MyFirebaseInstanceIdService.java  # FCM token management
├── MessageObservable.java            # Event bus for cross-component messaging
├── CustomOnClickListener.java        # Custom click handler
├── OnClickPrescriptionList.java      # Prescription callback
│
├── CareProvider/                     # 🏥 CARE PROVIDER FEATURES (Primary)
│   ├── Activities/                   # 21 Activities
│   ├── Fragments/                    # 35+ Fragments  
│   ├── Adapters/                     # RecyclerView adapters
│   ├── DataModels/                   # POJOs / DTOs
│   ├── Schedule/                     # Scheduling logic
│   └── WorkCancelReceiver.java       # Background work cancellation
│
├── Client/                           # 👤 CLIENT/PATIENT FEATURES (Shared code)
│   ├── Activities/                   # Payment, Diary, PDFs, etc.
│   ├── Fragments/                    # Client fragments
│   ├── Adapters/                     # Client adapters
│   └── BookSlots/                    # Appointment booking
│
├── CommonUser/                       # 🔗 SHARED USER FEATURES
│   ├── Activities/                   # Auth, Search, Profile
│   ├── Fragments/                    # Shared fragments
│   └── Adapters/                     # Shared adapters
│
├── Registration/                     # 🔐 AUTHENTICATION & ONBOARDING
│   └── Activities/
│       ├── SplashActivity            # Launcher activity
│       ├── LoginActivity             # Login screen
│       ├── RegisterCareProviderActivity  # Provider signup
│       ├── UserSelectionActivity     # User type selection
│       ├── VerifyAccountActivity     # Email verification
│       └── QuestionaireActivity      # Initial assessment
│
├── Collaboration/                    # 📹 VIDEO CALLING & WEBRTC
│   ├── Presence/
│   │   ├── CollaborationMain         # Legacy WebRTC (deprecated)
│   │   ├── IncomingCall              # Incoming call UI
│   │   └── FloatingViewService       # Picture-in-picture
│   ├── Common/                       # Bluetooth & audio helpers
│   └── NetWorkDetectionHelpers/      # Connectivity monitoring
│
├── Scheduling/                       # 📅 APPOINTMENT SCHEDULING
│   ├── WeeklySchedule/
│   │   └── WeeklyScheduleFragment    # Weekly calendar view
│   └── Services/
│       └── GetSlotsService           # Background slot sync
│
├── Stats/                            # 🛠️ UTILITIES & HELPERS
│   ├── Utils.java                    # Global utilities
│   ├── MySharedPreferences.java      # Preferences wrapper
│   ├── LocaleUtils.java              # Localization (AR/EN)
│   ├── LangHelper.java               # Language switching
│   ├── TransparentProgressDialog     # Loading dialogs
│   └── WeekDisplayActivity           # Week picker
│
├── navigation/                       # 🧭 NAVIGATION (Kotlin)
│   └── TabManager.kt                 # Bottom nav controller management
│
├── bottomnavbar/                     # 📱 CUSTOM BOTTOM NAV
│   └── [Custom navigation component]
│
├── views/                            # 🎨 CUSTOM VIEWS & NEWER FEATURES
│   ├── activity/
│   │   ├── AddPrescriptionActivity.kt   # Prescription UI (Kotlin)
│   │   ├── RegisterActivity.kt          # Registration flow (Kotlin)
│   │   └── OnboardingActivity.kt        # First-run (Kotlin)
│   └── fragments/
│       └── [Onboarding fragments]
│
├── workers/                          # ⚙️ BACKGROUND WORK (WorkManager)
│   └── [Background sync tasks]
│
└── BranchEvents/                     # 🔗 DEEP LINKING
    └── [Branch.io integration]

// 5 Tabs with dedicated NavControllers
┌─────────────────────────────────────────────────────────┐
│  BaseClientActivityMain (Main Container)                │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  ┌──────────┬──────────┬──────────┬──────────┬────────┐│
│  │   Home   │  Appts   │  Tests   │Homework  │  More  ││
│  └────┬─────┴────┬─────┴────┬─────┴────┬─────┴───┬────┘│
│       │          │          │          │         │     │
│  ┌────▼────┬─────▼────┬─────▼────┬─────▼────┬────▼───┐│
│  │ nav_home│nav_appts │nav_assess│nav_hw    │nav_more││
│  │  .xml   │ .xml     │ .xml     │ .xml     │ .xml   ││
│  └─────────┴──────────┴──────────┴──────────┴────────┘│
└─────────────────────────────────────────────────────────┘

// navigation/TabManager.kt
fun switchTab(tabId: Int) {
    currentController = when (tabId) {
        R.id.navigation_home        -> navHomeController
        R.id.navigation_appointments -> navAppointmentsController
        R.id.navigation_assessment  -> navAssessmentController
        R.id.navigation_homeworks   -> navHomeworksController
        R.id.navigation_more        -> navMoreController
        else -> navHomeController
    }
    tabHistory.push(tabId)
    showTab(tabId)
}

┌─────────────────┐
│  Activity/      │
│  Fragment       │
└────────┬────────┘
         │ 1. User action
         ↓
┌─────────────────┐
│ Fast Android    │
│ Networking      │ 2. HTTP Request
│ (Direct call)   │    .addHeaders("Authorization", "Bearer " + token)
└────────┬────────┘
         │
         ↓
┌─────────────────┐
│  Backend API    │ 3. JSON Response
└────────┬────────┘
         │
         ↓
┌─────────────────┐
│  JSONObject     │ 4. Manual parsing
│  Response       │    response.getJSONObject("data")
└────────┬────────┘
         │
         ↓
┌─────────────────┐
│  Update UI      │ 5. adapter.notifyDataSetChanged()
└─────────────────┘

// Direct API call in Fragment
AndroidNetworking.get(Utils.BaseURL + "api/CareProvider/GetAppointments")
    .addHeaders("Authorization", "Bearer " + mpref.GetUserToken())
    .setPriority(Priority.MEDIUM)
    .build()
    .getAsJSONObject(new JSONObjectRequestListener() {
        @Override
        public void onResponse(JSONObject response) {
            // Parse and update UI directly
            appointmentList.clear();
            JSONArray data = response.getJSONArray("data");
            // ... manual parsing
            adapter.notifyDataSetChanged();
        }
        @Override
        public void onError(ANError error) {
            Toast.makeText(context, "Error", Toast.LENGTH_SHORT).show();
        }
    });

┌──────────────────┐
│  Activities      │
│  (Video call,    │
│   Chat)          │
└────────┬─────────┘
         │ 1. Connect WebSocket
         ↓
┌──────────────────┐
│ WebSocketClient  │ 2. Send command (JSON)
│ (nv-websocket)   │    { "command": "JOIN_CALL", "meetingId": "..." }
└────────┬─────────┘
         │
         ↓
┌──────────────────┐
│  NodeServer      │ 3. Process & broadcast
└────────┬─────────┘
         │
         ↓
┌──────────────────┐
│ WebSocket        │ 4. Receive message
│ onMessageReceived│
└────────┬─────────┘
         │
         ↓
┌──────────────────┐
│ MessageObservable│ 5. Notify observers
│ (Event Bus)      │    messageObservable.notify(message)
└────────┬─────────┘
         │
         ↓
┌──────────────────┐
│ Update UI        │ 6. Handle in Activity
└──────────────────┘

┌──────────────────┐
│  Backend API     │ 1. Trigger event (new message, appointment)
└────────┬─────────┘
         │
         ↓
┌──────────────────┐
│  Firebase FCM    │ 2. Send push notification
└────────┬─────────┘
         │
         ↓
┌──────────────────┐
│ MyFirebase       │ 3. Receive notification
│ MessagingService │    onMessageReceived(RemoteMessage)
└────────┬─────────┘
         │
         ↓
┌──────────────────┐
│ Parse payload    │ 4. Extract notificationType, data
│ & route          │
└────────┬─────────┘
         │
         ├──→ Type 1: Open ChatMainActivity
         ├──→ Type 2: Open MyAppointCarePFragment
         ├──→ Type 3: Open OneToOneCallActivity
         └──→ Type 4: Open MyQyestionaireFragment

// MessageObservable.java (Observer Pattern)
public class MessageObservable extends Observable {
    private static MessageObservable instance;

    public static MessageObservable getInstance() {
        if (instance == null) instance = new MessageObservable();
        return instance;
    }

    public void updateValue(Object data) {
        setChanged();
        notifyObservers(data);
    }
}

// Fragment observes changes
MessageObservable.getInstance().addObserver(this);

@Override
public void update(Observable o, Object arg) {
    // Handle message
    if (arg instanceof NewMessageModel) {
        refreshChatList();
    }
}

┌─────────────────────────────────────────────────────────────┐
│                  VIDEO CALL SEQUENCE                         │
└─────────────────────────────────────────────────────────────┘

1. Appointment scheduled
   └─→ Backend creates meeting ID (VideoSDK API)

2. Call time arrives
   └─→ FCM notification sent to patient & provider
       Payload: { "notificationType": 3, "meetingId": "xxx", ... }

3. User taps notification
   └─→ Opens OneToOneCallActivity.kt

4. Initialize VideoSDK
   └─→ VideoSDK.initialize(context)
   └─→ VideoSDK.initMeeting(
           context,
           meetingId,
           participantName,
           micEnabled = true,
           webcamEnabled = true,
           ...
       )

5. Join meeting
   └─→ meeting.join()
   └─→ WebRTC connection established
   └─→ onMeetingJoined() callback

6. Remote participant joins
   └─→ onParticipantJoined(participant)
   └─→ Setup remote video view
   └─→ participant.onStreamEnabled() → render video

7. During call
   ├─→ meeting.muteMic() / unmuteMic()
   ├─→ meeting.disableWebcam() / enableWebcam()
   ├─→ meeting.changeWebcam() (switch camera)
   └─→ meeting.enableScreenShare()

8. End call
   └─→ meeting.leave()
   └─→ onMeetingLeft() callback
   └─→ finish() activity
   └─→ Backend API: UpdateAppointmentStatus("Completed")

┌─────────────────────────────────────────────────────────────┐
│              APPOINTMENT BOOKING SEQUENCE                    │
└─────────────────────────────────────────────────────────────┘

[Patient Side - Shared code in Client package]

1. FindCPFragment
   └─→ Search care providers
   └─→ API: GET /api/CareProvider/Search
       Filters: specialty, availability, rating

2. CarePDetailActivity
   └─→ View provider profile
   └─→ API: GET /api/CareProvider/GetProfile?id=xxx

3. ScheduleSessionActivity
   └─→ Select appointment type
   └─→ Navigate to WeeklyScheduleFragment

4. WeeklyScheduleFragment
   └─→ API: GET /api/CareProvider/GetAvailableSlots?date=xxx
   └─→ Display available slots
   └─→ User selects slot

5. SelectSlotActivity
   └─→ Confirm slot selection
   └─→ Choose payment method

6. SlotPaymentSuggestActivity
   └─→ Show payment options:
       ├─→ Wallet
       ├─→ Credit card (redirect to PaymentWebActivity)
       └─→ Insurance

7. PaymentWebActivity (WebView)
   └─→ Load payment gateway URL
   └─→ Process payment
   └─→ Return with payment status

8. BookingConfirmation1Activity
   └─→ API: POST /api/Appointment/CreateAppointment
       { careProviderId, slotId, paymentId, ... }
   └─→ Show confirmation
   └─→ Send FCM notification to provider

[Provider Side]

9. FCM notification received (MyFirebaseMessagingService)
   └─→ Type 2: New appointment
   └─→ Update badge count

10. MyAppointCarePFragment
    └─→ Refresh appointment list
    └─→ API: GET /api/CareProvider/GetAppointments
    └─→ New appointment appears

┌─────────────────────────────────────────────────────────────┐
│            ASSESSMENT MANAGEMENT SEQUENCE                    │
└─────────────────────────────────────────────────────────────┘

[Provider Creates Assessment]

1. InitialAssessmentAcitivity
   └─→ Select assessment template
       API: GET /api/Assessment/GetTemplates
   └─→ Customize questions
   └─→ Add/remove questions
   └─→ Set scoring logic

2. Save assessment
   └─→ API: POST /api/Assessment/CreateTemplate
       { name, questions: [...], ... }

3. Assign to patient
   └─→ From ClientHistoryActivity
   └─→ Select patient
   └─→ Select assessment
   └─→ API: POST /api/Assessment/AssignToPatient
       { patientId, assessmentId, dueDate, ... }
   └─→ FCM notification to patient

[Patient Completes Assessment]

4. Patient receives notification
   └─→ Opens MyQyestionaireFragment
   └─→ API: GET /api/Assessment/GetAssigned
   └─→ List of pending assessments

5. Start assessment
   └─→ QuestionnaireFragment
   └─→ Display questions one by one
   └─→ Collect responses

6. Submit assessment
   └─→ API: POST /api/Assessment/Submit
       { assessmentId, responses: [...], ... }
   └─→ FCM notification to provider

[Provider Reviews Response]

7. Provider receives notification
   └─→ Opens MyQyestionaireFragment
   └─→ API: GET /api/Assessment/GetCompleted

8. View patient response
   └─→ FilledAssessmentViewActivity
   └─→ API: GET /api/Assessment/GetResponse?id=xxx
   └─→ Display answers with scoring
   └─→ Provider adds feedback

9. Save feedback
   └─→ API: POST /api/Assessment/SubmitFeedback
       { assessmentId, patientId, feedback, ... }

┌─────────────────────────────────────────────────────────────┐
│                  MESSAGING SEQUENCE                          │
└─────────────────────────────────────────────────────────────┘

1. Open conversations list
   └─→ ChatMainActivity
   └─→ API: GET /api/Messaging/GetConversations
   └─→ Display list (ConversationListAdapter)

2. Select conversation
   └─→ ConversationActivity
   └─→ API: GET /api/Messaging/GetMessages?conversationId=xxx
   └─→ Display messages (RecyclerView)

3. Send message
   └─→ User types message
   └─→ API: POST /api/Messaging/SendMessage
       { conversationId, message, type: "text", ... }
   └─→ Optimistically add to UI
   └─→ Backend sends FCM to recipient

4. Receive message (real-time)
   └─→ MyFirebaseMessagingService
   └─→ Type 1: New message
   └─→ If ConversationActivity open for this conversation:
       └─→ MessageObservable.notify(message)
       └─→ ConversationActivity.update() → append message
   └─→ Else:
       └─→ Show notification
       └─→ Update badge count

5. Send attachment
   └─→ Select image/file
   └─→ Upload to MediaAPI first
       POST /api/Media/Upload
   └─→ Get file URL
   └─→ Send message with attachment URL
       POST /api/Messaging/SendMessage
       { message: "Photo", type: "image", attachmentUrl: "..." }

6. Mark as read
   └─→ onResume() in ConversationActivity
   └─→ API: POST /api/Messaging/MarkAsRead
       { conversationId, ... }
   └─→ Clear notification

┌─────────────────────────────────────────────────────────────┐
│            SCHEDULE MANAGEMENT SEQUENCE                      │
└─────────────────────────────────────────────────────────────┘

1. View current schedule
   └─→ MarkAvailabiltyActivity
   └─→ API: GET /api/CareProvider/GetSchedule
   └─→ Display weekly availability

2. Set recurring availability
   └─→ Select day (e.g., Monday)
   └─→ Add time slot (9:00 AM - 5:00 PM)
   └─→ Set session duration (30/45/60 min)
   └─→ API: POST /api/CareProvider/SetRecurringAvailability
       { dayOfWeek: 1, startTime: "09:00", endTime: "17:00", sessionDuration: 45, ... }

3. Block specific dates
   └─→ Select date (e.g., vacation)
   └─→ API: POST /api/CareProvider/BlockDate
       { date: "2025-12-25", reason: "Holiday", ... }

4. Override availability
   └─→ For specific date, change hours
   └─→ API: POST /api/CareProvider/SetCustomAvailability
       { date: "2025-11-15", startTime: "10:00", endTime: "14:00", ... }

5. Availability affects booking
   └─→ WeeklyScheduleFragment (patient side)
   └─→ API: GET /api/CareProvider/GetAvailableSlots?providerId=xxx&date=yyy
   └─→ Only shows available slots based on provider schedule

public static String BaseURL = "https://dev2.innotech-sa.com/Psyter/Master/APIs/";
public static String BaseURLDocument = "https://dev2.innotech-sa.com/Psyter/Master/APIs/";
public static String BaseURLVideo = "https://dev2.innotech-sa.com/Psyter/Master/APIs/";

.addHeaders("Authorization", "Bearer " + mpref.GetUserToken())

switch (notificationType) {
    case "1": // New message
        openChatActivity(conversationId);
        break;
    case "2": // Appointment reminder
        openAppointmentsFragment();
        break;
    case "3": // Incoming call
        openVideoCallActivity(meetingId);
        break;
    case "4": // Assessment assigned
        openAssessmentsFragment();
        break;
    // ...
}

{
  "command": "JOIN_CALL",
  "meetingId": "abc123",
  "userId": "user123",
  "userType": "CareProvider"
}

@Override
public void onCreate() {
    super.onCreate();
    VideoSDK.initialize(this);
}

App → PaymentWebActivity (WebView)
    → Load payment URL (Smart Routing payment gateway)
    → User completes payment in browser
    → Redirect back to app with payment status
    → Parse URL parameters
    → Update appointment status

String paymentUrl = Utils.BaseURLPayment + 
    "serviceProviderId=" + providerId +
    "&serviceConsumerId=" + userId +
    "&amount=" + amount +
    "&bookingId=" + bookingId;
webView.loadUrl(paymentUrl);

┌──────────────┐
│   Activity   │ ← Controller
│  (Fragment)  │
└──────┬───────┘
       │
       ↓
┌──────────────┐
│   Adapter    │ ← View
│ (RecyclerView)│
└──────┬───────┘
       │
       ↓
┌──────────────┐
│  DataModel   │ ← Model (POJO)
└──────────────┘

┌──────────────┐
│   Activity   │ ← View
│  (Fragment)  │   observes LiveData
└──────┬───────┘
       │
       ↓
┌──────────────┐
│  ViewModel   │ ← (Not yet implemented)
│  (missing)   │
└──────┬───────┘
       │
       ↓
┌──────────────┐
│  Repository  │ ← (Not yet implemented)
│  (missing)   │
└──────┬───────┘
       │
       ↓
┌──────────────┐
│  DataModel   │ ← Model
└──────────────┘

MessageObservable (Event Bus)
    ↓
Fragments register as observers
    ↓
Events broadcast to all observers

// Utils.java
public class Utils {
    private static Utils instance;

    public static Utils getInstance() {
        if (instance == null) instance = new Utils();
        return instance;
    }
}

┌─────────────────────────────────────────────────────────────┐
│                   RECOMMENDED ARCHITECTURE                   │
└─────────────────────────────────────────────────────────────┘

┌──────────────┐
│   Activity   │ ← View (only UI logic)
│  (Fragment)  │   observes LiveData/StateFlow
└──────┬───────┘
       │
       ↓
┌──────────────┐
│  ViewModel   │ ← Presentation logic
│  + LiveData  │   exposes UI state
└──────┬───────┘
       │
       ↓
┌──────────────┐
│  Repository  │ ← Data source coordination
│              │   (API + Cache + Database)
└──────┬───────┘
       │
       ├──→ API (Retrofit)
       ├──→ LocalDatabase (Room)
       └──→ SharedPreferences