public class CollaborationMain extends AppCompatActivity {
    // ❌ Responsibility 1: UI Management
    private RecyclerView rvMessages;
    private EditText etMessage;
    private Button btnSend;
    // ... 50+ UI components

    // ❌ Responsibility 2: WebRTC Video Conferencing
    private PeerConnectionFactory peerConnectionFactory;
    private PeerConnection peerConnection;
    private VideoTrack localVideoTrack;
    // ... 20+ WebRTC fields

    // ❌ Responsibility 3: Chat/Messaging
    private List<ChatMessage> messages;
    private ChatAdapter chatAdapter;
    // ... messaging logic

    // ❌ Responsibility 4: File Sharing
    private void shareFile() { /* 150 lines */ }
    private void uploadFile() { /* 200 lines */ }

    // ❌ Responsibility 5: Screen Sharing
    private void startScreenShare() { /* 180 lines */ }

    // ❌ Responsibility 6: Recording
    private MediaRecorder mediaRecorder;
    private void startRecording() { /* 120 lines */ }

    // ❌ Responsibility 7: Network Communication
    private void sendMessageToServer() { /* 100 lines */ }
    private void connectWebSocket() { /* 150 lines */ }

    // ❌ Responsibility 8: Permission Management
    private void requestCameraPermission() { /* 80 lines */ }
    private void requestMicrophonePermission() { /* 80 lines */ }

    // ❌ Responsibility 9: Audio Management
    private AudioManager audioManager;
    private void toggleMute() { /* 60 lines */ }

    // ❌ Responsibility 10: Session Management
    private void startSession() { /* 200 lines */ }
    private void endSession() { /* 150 lines */ }

    // ❌ Responsibility 11: Analytics/Logging
    private void logEvent() { /* 50 lines */ }

    // ❌ Responsibility 12: Error Handling
    private void handleWebRTCError() { /* 100 lines */ }
    private void handleNetworkError() { /* 100 lines */ }

    // Total: 127 methods, 3,014 lines
}

// setupWebRTC() - 350 lines, Cyclomatic Complexity: 85
private void setupWebRTC() {
    // Initialize peer connection factory (50 lines)
    PeerConnectionFactory.InitializationOptions initOptions = 
        PeerConnectionFactory.InitializationOptions.builder(this)
            .setEnableInternalTracer(true)
            .setFieldTrials("WebRTC-H264HighProfile/Enabled/")
            .createInitializationOptions();
    PeerConnectionFactory.initialize(initOptions);

    // Build options (30 lines)
    PeerConnectionFactory.Options options = new PeerConnectionFactory.Options();
    options.disableEncryption = false;
    options.disableNetworkMonitor = false;

    // Create video capturer (60 lines)
    VideoCapturer videoCapturer = createVideoCapturer();
    if (videoCapturer == null) {
        showError("Camera not available");
        return;
    }

    // Create video source (40 lines)
    VideoSource videoSource = peerConnectionFactory.createVideoSource(
        videoCapturer.isScreencast()
    );
    videoCapturer.initialize(
        SurfaceTextureHelper.create("CaptureThread", eglBase.getEglBaseContext()),
        this,
        videoSource.getCapturerObserver()
    );
    videoCapturer.startCapture(1280, 720, 30);

    // Create video track (30 lines)
    localVideoTrack = peerConnectionFactory.createVideoTrack("100", videoSource);
    localVideoTrack.setEnabled(true);
    localVideoTrack.addSink(localVideoView);

    // Create audio source (40 lines)
    AudioSource audioSource = peerConnectionFactory.createAudioSource(
        new MediaConstraints()
    );
    AudioTrack localAudioTrack = peerConnectionFactory.createAudioTrack("101", audioSource);
    localAudioTrack.setEnabled(true);

    // ICE servers configuration (50 lines)
    List<PeerConnection.IceServer> iceServers = new ArrayList<>();
    iceServers.add(PeerConnection.IceServer.builder("stun:stun.l.google.com:19302").createIceServer());
    // ... 10+ more ICE servers

    // RTC configuration (30 lines)
    PeerConnection.RTCConfiguration rtcConfig = new PeerConnection.RTCConfiguration(iceServers);
    rtcConfig.bundlePolicy = PeerConnection.BundlePolicy.MAXBUNDLE;
    rtcConfig.rtcpMuxPolicy = PeerConnection.RtcpMuxPolicy.REQUIRE;
    rtcConfig.tcpCandidatePolicy = PeerConnection.TcpCandidatePolicy.DISABLED;
    rtcConfig.continualGatheringPolicy = PeerConnection.ContinualGatheringPolicy.GATHER_CONTINUALLY;
    rtcConfig.keyType = PeerConnection.KeyType.ECDSA;
    rtcConfig.sdpSemantics = PeerConnection.SdpSemantics.UNIFIED_PLAN;

    // Peer connection observer (50 lines of nested callbacks)
    PeerConnection.Observer pcObserver = new PeerConnection.Observer() {
        @Override
        public void onSignalingChange(PeerConnection.SignalingState signalingState) {
            // 20 lines
        }

        @Override
        public void onIceConnectionChange(PeerConnection.IceConnectionState iceConnectionState) {
            // 30 lines with nested if-else
        }

        // ... 10+ more callback methods
    };

    // Create peer connection (20 lines)
    peerConnection = peerConnectionFactory.createPeerConnection(rtcConfig, pcObserver);

    // Add streams (20 lines)
    peerConnection.addTrack(localVideoTrack);
    peerConnection.addTrack(localAudioTrack);

    // Data channel setup (30 lines)
    DataChannel.Init init = new DataChannel.Init();
    dataChannel = peerConnection.createDataChannel("chat", init);

    // ... continues for 350 lines total
}

CollaborationMain.java (3,014 lines)
├── UI Management (500 lines)
├── WebRTC Setup (350 lines)
├── Chat/Messaging (400 lines)
├── File Sharing (350 lines)
├── Screen Sharing (300 lines)
├── Recording (250 lines)
├── Network/WebSocket (400 lines)
├── Permissions (200 lines)
├── Audio Management (150 lines)
├── Session Management (450 lines)
├── Analytics (100 lines)
└── Error Handling (564 lines)

collaboration/
├── ui/
│   ├── CollaborationActivity.java (250 lines) ✅
│   ├── CollaborationViewModel.java (150 lines) ✅
│   └── CollaborationAdapter.java (100 lines) ✅
├── webrtc/
│   ├── WebRTCManager.java (300 lines) ✅
│   ├── PeerConnectionFactory.java (200 lines) ✅
│   └── WebRTCConfig.java (100 lines) ✅
├── chat/
│   ├── ChatManager.java (200 lines) ✅
│   └── ChatRepository.java (150 lines) ✅
├── file/
│   ├── FileShareManager.java (200 lines) ✅
│   └── FileUploadService.java (150 lines) ✅
├── screen/
│   └── ScreenShareManager.java (200 lines) ✅
├── recording/
│   └── SessionRecorder.java (200 lines) ✅
├── network/
│   ├── WebSocketManager.java (250 lines) ✅
│   └── SignalingClient.java (150 lines) ✅
├── permission/
│   └── PermissionManager.java (150 lines) ✅
├── audio/
│   └── AudioManager.java (150 lines) ✅
└── session/
    ├── SessionManager.java (300 lines) ✅
    └── SessionRepository.java (150 lines) ✅

// webrtc/WebRTCManager.java (NEW FILE)
public class WebRTCManager {
    private PeerConnectionFactory peerConnectionFactory;
    private PeerConnection peerConnection;
    private WebRTCConfig config;
    private WebRTCCallback callback;

    public WebRTCManager(Context context, WebRTCConfig config, WebRTCCallback callback) {
        this.config = config;
        this.callback = callback;
        initializePeerConnectionFactory(context);
    }

    /**
     * Initialize WebRTC components
     * Single responsibility: WebRTC setup
     */
    public void initialize() {
        createPeerConnectionFactory();
        setupLocalTracks();
        createPeerConnection();
    }

    private void createPeerConnectionFactory() {
        PeerConnectionFactory.InitializationOptions initOptions = 
            PeerConnectionFactory.InitializationOptions.builder(context)
                .setEnableInternalTracer(config.isTracingEnabled())
                .setFieldTrials(config.getFieldTrials())
                .createInitializationOptions();

        PeerConnectionFactory.initialize(initOptions);

        peerConnectionFactory = PeerConnectionFactory.builder()
            .setOptions(config.getFactoryOptions())
            .createPeerConnectionFactory();
    }

    private void setupLocalTracks() {
        // Extract video/audio setup to separate methods
        localVideoTrack = createVideoTrack();
        localAudioTrack = createAudioTrack();
    }

    private VideoTrack createVideoTrack() {
        VideoCapturer videoCapturer = createVideoCapturer();
        VideoSource videoSource = peerConnectionFactory.createVideoSource(false);

        videoCapturer.initialize(
            SurfaceTextureHelper.create("CaptureThread", eglBase.getEglBaseContext()),
            context,
            videoSource.getCapturerObserver()
        );

        videoCapturer.startCapture(
            config.getVideoWidth(),
            config.getVideoHeight(),
            config.getVideoFps()
        );

        return peerConnectionFactory.createVideoTrack("video_track", videoSource);
    }

    // Additional methods: 300 lines total (down from 3,014)
}

// chat/ChatManager.java (NEW FILE)
public class ChatManager {
    private ChatRepository repository;
    private WebSocketManager webSocketManager;
    private ChatCallback callback;

    public ChatManager(ChatRepository repository, 
                      WebSocketManager webSocketManager,
                      ChatCallback callback) {
        this.repository = repository;
        this.webSocketManager = webSocketManager;
        this.callback = callback;
    }

    /**
     * Send chat message
     * Single responsibility: Chat operations
     */
    public void sendMessage(String message) {
        // Validate
        if (TextUtils.isEmpty(message)) {
            callback.onError("Message cannot be empty");
            return;
        }

        // Create message object
        ChatMessage chatMessage = new ChatMessage(
            UUID.randomUUID().toString(),
            message,
            getCurrentUserId(),
            System.currentTimeMillis()
        );

        // Save locally
        repository.saveMessage(chatMessage);

        // Send to server
        webSocketManager.sendMessage(chatMessage.toJson());

        // Notify UI
        callback.onMessageSent(chatMessage);
    }

    public void receiveMessage(String json) {
        try {
            ChatMessage message = ChatMessage.fromJson(json);
            repository.saveMessage(message);
            callback.onMessageReceived(message);
        } catch (JSONException e) {
            Timber.e(e, "Failed to parse chat message");
            callback.onError("Invalid message format");
        }
    }

    // Total: 200 lines (extracted from 3,014-line file)
}

// ui/CollaborationActivity.java (REFACTORED - 250 lines down from 3,014)
public class CollaborationActivity extends AppCompatActivity {

    // ✅ Dependencies injected
    private WebRTCManager webRTCManager;
    private ChatManager chatManager;
    private FileShareManager fileShareManager;
    private SessionManager sessionManager;
    private CollaborationViewModel viewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_collaboration);

        // ✅ Initialize dependencies (could use Dagger/Hilt)
        initializeDependencies();

        // ✅ Setup UI
        initializeViews();

        // ✅ Observe ViewModel
        observeViewModel();

        // ✅ Start session
        startCollaborationSession();
    }

    private void initializeDependencies() {
        // WebRTC
        WebRTCConfig webRTCConfig = new WebRTCConfig.Builder()
            .setVideoResolution(1280, 720)
            .setVideoFps(30)
            .build();
        webRTCManager = new WebRTCManager(this, webRTCConfig, webRTCCallback);

        // Chat
        ChatRepository chatRepository = new ChatRepository(database);
        WebSocketManager webSocketManager = new WebSocketManager(getWebSocketUrl());
        chatManager = new ChatManager(chatRepository, webSocketManager, chatCallback);

        // File sharing
        fileShareManager = new FileShareManager(this, fileCallback);

        // Session
        sessionManager = new SessionManager(this, sessionCallback);

        // ViewModel
        viewModel = new ViewModelProvider(this).get(CollaborationViewModel.class);
    }

    private void initializeViews() {
        // UI setup (50 lines)
        rvMessages = findViewById(R.id.rv_messages);
        etMessage = findViewById(R.id.et_message);
        btnSend = findViewById(R.id.btn_send);

        btnSend.setOnClickListener(v -> sendMessage());
    }

    private void sendMessage() {
        String message = etMessage.getText().toString();
        chatManager.sendMessage(message);
        etMessage.setText("");
    }

    // ✅ Clean callbacks - just update UI
    private final ChatCallback chatCallback = new ChatCallback() {
        @Override
        public void onMessageSent(ChatMessage message) {
            runOnUiThread(() -> {
                adapter.addMessage(message);
                rvMessages.scrollToPosition(adapter.getItemCount() - 1);
            });
        }

        @Override
        public void onMessageReceived(ChatMessage message) {
            runOnUiThread(() -> adapter.addMessage(message));
        }

        @Override
        public void onError(String error) {
            runOnUiThread(() -> Toast.makeText(this, error, Toast.LENGTH_SHORT).show());
        }
    };

    // Total: 250 lines (down from 3,014)
    // Cyclomatic Complexity: 12 (down from 850)
    // Responsibilities: 1 (UI coordination) (down from 12)
}

Activities/Fragments (3,000+ lines each)
├── Business Logic (mixed in)
├── Data Access (mixed in)
├── UI Logic (mixed in)
├── Network Calls (mixed in)
└── Everything Else (mixed in)

// LoginActivity.java - Lines 200-350
private void loginUser() {
    // ❌ Input validation in Activity
    String email = etEmail.getText().toString();
    if (email.isEmpty()) {
        etEmail.setError("Email required");
        return;
    }

    if (!Patterns.EMAIL_ADDRESS.matcher(email).matches()) {
        etEmail.setError("Invalid email");
        return;
    }

    String password = etPassword.getText().toString();
    if (password.length() < 8) {
        etPassword.setError("Password too short");
        return;
    }

    // ❌ Network call directly in Activity
    showLoading();
    AndroidNetworking.post(Utils.BaseURL + "Authenticate")
        .addBodyParameter("email", email)
        .addBodyParameter("password", password)
        .build()
        .getAsJSONObject(new JSONObjectRequestListener() {
            @Override
            public void onResponse(JSONObject response) {
                hideLoading();

                try {
                    // ❌ JSON parsing in Activity
                    String token = response.getString("access_token");
                    String userId = response.getString("user_id");
                    String role = response.getString("role");

                    // ❌ Data storage in Activity
                    SharedPreferences prefs = getSharedPreferences("UserPrefs", MODE_PRIVATE);
                    prefs.edit()
                        .putString("token", token)
                        .putString("user_id", userId)
                        .putString("role", role)
                        .apply();

                    // ❌ Navigation logic in Activity
                    if (role.equals("patient")) {
                        Intent intent = new Intent(LoginActivity.this, BaseClientActivityMain.class);
                        startActivity(intent);
                    } else if (role.equals("provider")) {
                        Intent intent = new Intent(LoginActivity.this, BaseProviderActivityMain.class);
                        startActivity(intent);
                    }

                    finish();

                } catch (JSONException e) {
                    e.printStackTrace();
                    Toast.makeText(LoginActivity.this, "Login failed", Toast.LENGTH_SHORT).show();
                }
            }

            @Override
            public void onError(ANError error) {
                hideLoading();
                // ❌ Error handling mixed with UI
                if (error.getErrorCode() == 401) {
                    Toast.makeText(LoginActivity.this, "Invalid credentials", Toast.LENGTH_SHORT).show();
                } else if (error.getErrorCode() == 0) {
                    Toast.makeText(LoginActivity.this, "Network error", Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(LoginActivity.this, "Something went wrong", Toast.LENGTH_SHORT).show();
                }
            }
        });
}

📱 Presentation Layer (UI)
├── Activities/Fragments (UI only, ~200 lines each)
├── ViewModels (UI state management)
└── Adapters (RecyclerView adapters)
    ↓
💼 Domain Layer (Business Logic)
├── Use Cases (business operations)
├── Models (domain entities)
└── Repository Interfaces (contracts)
    ↓
🗄️ Data Layer (Data Sources)
├── Repository Implementations
├── API Client (network)
├── Local Database (Room)
└── SharedPreferences (settings)
    ↓
🔧 Infrastructure
├── Dependency Injection (Hilt/Dagger)
├── Network Module
└── Database Module

// LoginActivity.java (current) - 850 lines
// Everything mixed together

// domain/usecase/LoginUseCase.java (NEW)
public class LoginUseCase {
    private final AuthRepository authRepository;
    private final UserRepository userRepository;

    @Inject
    public LoginUseCase(AuthRepository authRepository, UserRepository userRepository) {
        this.authRepository = authRepository;
        this.userRepository = userRepository;
    }

    /**
     * Execute login
     * Pure business logic - no Android dependencies
     */
    public Result<User> execute(String email, String password) {
        // Validate input
        if (!EmailValidator.isValid(email)) {
            return Result.error("Invalid email format");
        }

        if (password.length() < 8) {
            return Result.error("Password must be at least 8 characters");
        }

        // Attempt authentication
        try {
            AuthResponse authResponse = authRepository.authenticate(email, password);

            // Save token
            authRepository.saveToken(authResponse.getToken());

            // Get user profile
            User user = userRepository.getUserProfile(authResponse.getUserId());

            return Result.success(user);

        } catch (NetworkException e) {
            return Result.error("Network error: " + e.getMessage());
        } catch (AuthenticationException e) {
            return Result.error("Invalid credentials");
        } catch (Exception e) {
            return Result.error("Login failed: " + e.getMessage());
        }
    }
}

// presentation/login/LoginViewModel.java (NEW)
@HiltViewModel
public class LoginViewModel extends ViewModel {
    private final LoginUseCase loginUseCase;

    private final MutableLiveData<LoginState> loginState = new MutableLiveData<>();
    public LiveData<LoginState> getLoginState() { return loginState; }

    @Inject
    public LoginViewModel(LoginUseCase loginUseCase) {
        this.loginUseCase = loginUseCase;
    }

    /**
     * Handle login action
     * UI logic only - delegates to use case
     */
    public void login(String email, String password) {
        // Update UI state
        loginState.setValue(LoginState.loading());

        // Execute use case in background
        viewModelScope.launch(Dispatchers.IO) {
            Result<User> result = loginUseCase.execute(email, password);

            // Update UI state with result
            if (result.isSuccess()) {
                loginState.postValue(LoginState.success(result.getData()));
            } else {
                loginState.postValue(LoginState.error(result.getError()));
            }
        }
    }
}

// presentation/login/LoginActivity.java (REFACTORED - 150 lines down from 850)
@AndroidEntryPoint
public class LoginActivity extends AppCompatActivity {

    @Inject
    LoginViewModel viewModel;  // Injected by Hilt

    private ActivityLoginBinding binding;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        binding = ActivityLoginBinding.inflate(getLayoutInflater());
        setContentView(binding.getRoot());

        setupViews();
        observeViewModel();
    }

    private void setupViews() {
        binding.btnLogin.setOnClickListener(v -> handleLogin());
    }

    private void handleLogin() {
        String email = binding.etEmail.getText().toString();
        String password = binding.etPassword.getText().toString();

        // Delegate to ViewModel
        viewModel.login(email, password);
    }

    private void observeViewModel() {
        viewModel.getLoginState().observe(this, state -> {
            switch (state.getStatus()) {
                case LOADING:
                    showLoading();
                    break;

                case SUCCESS:
                    hideLoading();
                    navigateToHome(state.getData());
                    break;

                case ERROR:
                    hideLoading();
                    showError(state.getError());
                    break;
            }
        });
    }

    private void showLoading() {
        binding.progressBar.setVisibility(View.VISIBLE);
        binding.btnLogin.setEnabled(false);
    }

    private void hideLoading() {
        binding.progressBar.setVisibility(View.GONE);
        binding.btnLogin.setEnabled(true);
    }

    private void showError(String message) {
        Snackbar.make(binding.getRoot(), message, Snackbar.LENGTH_LONG).show();
    }

    private void navigateToHome(User user) {
        Intent intent = HomeActivity.createIntent(this, user);
        startActivity(intent);
        finish();
    }

    // Total: 150 lines (down from 850)
    // Testable: ✅ (ViewModel can be unit tested)
    // Reusable: ✅ (LoginUseCase reused across app)
    // Maintainable: ✅ (clear separation of concerns)
}

// data/repository/AuthRepositoryImpl.java (NEW)
public class AuthRepositoryImpl implements AuthRepository {
    private final ApiService apiService;
    private final SecurePrefsManager prefsManager;

    @Inject
    public AuthRepositoryImpl(ApiService apiService, SecurePrefsManager prefsManager) {
        this.apiService = apiService;
        this.prefsManager = prefsManager;
    }

    @Override
    public AuthResponse authenticate(String email, String password) throws NetworkException {
        try {
            Response<AuthResponse> response = apiService.authenticate(
                new AuthRequest(email, password)
            ).execute();

            if (response.isSuccessful() && response.body() != null) {
                return response.body();
            } else {
                throw new AuthenticationException("Authentication failed");
            }

        } catch (IOException e) {
            throw new NetworkException("Network error", e);
        }
    }

    @Override
    public void saveToken(String token) {
        prefsManager.saveAuthToken(token);
    }

    @Override
    public String getToken() {
        return prefsManager.getAuthToken();
    }
}