Android Repository - Code Quality Report¶

Code Quality Breakdown:
├─ Structure & Organization: ████████░░ 55/100
├─ Complexity Management:    ████░░░░░░ 40/100
├─ Error Handling:           ███░░░░░░░ 30/100
├─ Performance:              ██████░░░░ 60/100
├─ Maintainability:          █████░░░░░ 50/100
└─ Code Cleanliness:         ██████░░░░ 60/100

Total Project Lines:        ~52,000
├─ Production Code:         ~48,000 (92%)
├─ Comments:                ~2,500  (5%)
├─ Blank Lines:             ~1,500  (3%)
└─ Test Code:               0       (0%) ❌

Production Code Breakdown:
├─ Activities:              ~15,000 (31%)
├─ Fragments:               ~12,000 (25%)
├─ Adapters:                ~8,000  (17%)
├─ DataModels:              ~5,000  (10%)
├─ Utilities:               ~4,000  (8%)
└─ Other:                   ~4,000  (9%)

private void setupWebRTC() {
    try {
        if (peerConnectionFactory == null) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                // Initialize EglBase
                if (rootEglBase == null) {
                    rootEglBase = EglBase.create();
                }

                // Initialize PeerConnectionFactory
                PeerConnectionFactory.InitializationOptions initOptions = 
                    PeerConnectionFactory.InitializationOptions.builder(this)
                        .setEnableInternalTracer(true)
                        .createInitializationOptions();
                PeerConnectionFactory.initialize(initOptions);

                // Create factory
                PeerConnectionFactory.Options options = new PeerConnectionFactory.Options();

                DefaultVideoEncoderFactory encoderFactory = 
                    new DefaultVideoEncoderFactory(
                        rootEglBase.getEglBaseContext(), true, true);

                DefaultVideoDecoderFactory decoderFactory = 
                    new DefaultVideoDecoderFactory(rootEglBase.getEglBaseContext());

                peerConnectionFactory = PeerConnectionFactory.builder()
                    .setOptions(options)
                    .setVideoEncoderFactory(encoderFactory)
                    .setVideoDecoderFactory(decoderFactory)
                    .createPeerConnectionFactory();

                // Create video source
                videoSource = peerConnectionFactory.createVideoSource(false);

                // Create video track
                localVideoTrack = peerConnectionFactory.createVideoTrack(
                    "video_track", videoSource);

                // Create audio source
                audioSource = peerConnectionFactory.createAudioSource(
                    new MediaConstraints());

                // Create audio track
                localAudioTrack = peerConnectionFactory.createAudioTrack(
                    "audio_track", audioSource);

                // Setup video capturer
                if (videoCapturer == null) {
                    videoCapturer = createCameraCapturer(
                        new Camera2Enumerator(this));
                }

                if (videoCapturer != null) {
                    VideoSurfaceView localView = findViewById(R.id.local_view);
                    localView.setMirror(true);
                    localView.init(rootEglBase.getEglBaseContext(), null);

                    SurfaceTextureHelper surfaceTextureHelper = 
                        SurfaceTextureHelper.create(
                            "CaptureThread", rootEglBase.getEglBaseContext());

                    videoCapturer.initialize(
                        surfaceTextureHelper, this, videoSource.getCapturerObserver());

                    videoCapturer.startCapture(1280, 720, 30);

                    localVideoTrack.addSink(localView);
                }

                // Create peer connection
                List<PeerConnection.IceServer> iceServers = new ArrayList<>();
                iceServers.add(PeerConnection.IceServer.builder("stun:stun.l.google.com:19302").createIceServer());

                // Add TURN servers if available
                if (turnServerUrl != null && !turnServerUrl.isEmpty()) {
                    iceServers.add(
                        PeerConnection.IceServer.builder(turnServerUrl)
                            .setUsername(turnUsername)
                            .setPassword(turnPassword)
                            .createIceServer());
                }

                PeerConnection.RTCConfiguration rtcConfig = 
                    new PeerConnection.RTCConfiguration(iceServers);
                rtcConfig.tcpCandidatePolicy = 
                    PeerConnection.TcpCandidatePolicy.DISABLED;
                rtcConfig.bundlePolicy = 
                    PeerConnection.BundlePolicy.MAXBUNDLE;
                rtcConfig.rtcpMuxPolicy = 
                    PeerConnection.RtcpMuxPolicy.REQUIRE;
                rtcConfig.continualGatheringPolicy = 
                    PeerConnection.ContinualGatheringPolicy.GATHER_CONTINUALLY;
                rtcConfig.keyType = 
                    PeerConnection.KeyType.ECDSA;

                peerConnection = peerConnectionFactory.createPeerConnection(
                    rtcConfig, peerConnectionObserver);

                if (peerConnection != null) {
                    // Add local media stream
                    MediaStream localStream = peerConnectionFactory.createLocalMediaStream("local_stream");
                    localStream.addTrack(localVideoTrack);
                    localStream.addTrack(localAudioTrack);
                    peerConnection.addStream(localStream);

                    // Setup remote view
                    VideoSurfaceView remoteView = findViewById(R.id.remote_view);
                    remoteView.init(rootEglBase.getEglBaseContext(), null);

                    // Handle call type (audio/video)
                    if (isVideoCall) {
                        localVideoTrack.setEnabled(true);
                        localView.setVisibility(View.VISIBLE);
                    } else {
                        localVideoTrack.setEnabled(false);
                        localView.setVisibility(View.GONE);
                    }

                    // Audio routing
                    AudioManager audioManager = (AudioManager) getSystemService(AUDIO_SERVICE);
                    audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
                    audioManager.setSpeakerphoneOn(isSpeakerOn);
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        // Show error to user
        showError("Failed to initialize video call");
    }
}

// Split into smaller methods
private void setupWebRTC() {
    initializePeerConnectionFactory();
    createMediaTracks();
    setupVideoCapture();
    createPeerConnection();
    setupMediaStreams();
}

private void initializePeerConnectionFactory() {
    if (peerConnectionFactory != null) return;

    PeerConnectionFactory.InitializationOptions initOptions = 
        createInitializationOptions();
    PeerConnectionFactory.initialize(initOptions);

    peerConnectionFactory = createFactoryWithCodecs();
}

private PeerConnectionFactory createFactoryWithCodecs() {
    DefaultVideoEncoderFactory encoderFactory = createEncoderFactory();
    DefaultVideoDecoderFactory decoderFactory = createDecoderFactory();

    return PeerConnectionFactory.builder()
        .setOptions(new PeerConnectionFactory.Options())
        .setVideoEncoderFactory(encoderFactory)
        .setVideoDecoderFactory(decoderFactory)
        .createPeerConnectionFactory();
}

// ... and so on (each method <20 lines, complexity <10)

// Utils.java contains EVERYTHING
public class Utils {
    // 150+ API endpoint strings
    public static String BaseURL = "...";
    public static String EndpointLogin = "Authenticate";
    public static String EndpointRegister = "Patient/RegisterClient";
    // ... 145 more endpoints ...

    // Date/Time utilities
    public static String formatDate(String date) { ... }
    public static String parseDate(String date) { ... }
    public static boolean isDateInPast(String date) { ... }
    // ... 20 more date methods ...

    // UI utilities
    public static void showToast(Context ctx, String msg) { ... }
    public static void showDialog(Context ctx, String msg) { ... }
    public static void hideKeyboard(Activity activity) { ... }
    // ... 15 more UI methods ...

    // Validation utilities
    public static boolean isValidEmail(String email) { ... }
    public static boolean isValidPhone(String phone) { ... }
    public static boolean isValidPassword(String pwd) { ... }
    // ... 10 more validation methods ...

    // Network utilities
    public static boolean isNetworkAvailable(Context ctx) { ... }
    public static String getDeviceId(Context ctx) { ... }
    // ... 8 more network methods ...

    // String utilities
    public static String capitalizeFirstLetter(String str) { ... }
    public static String removeSpaces(String str) { ... }
    // ... 12 more string methods ...

    // Image utilities
    public static Bitmap resizeBitmap(Bitmap bitmap, int size) { ... }
    public static String bitmapToBase64(Bitmap bitmap) { ... }
    // ... 6 more image methods ...

    // ... and 50+ more miscellaneous methods
}

// Split into focused classes
ApiEndpoints.java       // 20 lines - API URLs only
DateUtils.java          // 150 lines - Date/time operations
UiUtils.java            // 100 lines - UI helpers
ValidationUtils.java    // 80 lines - Input validation
NetworkUtils.java       // 60 lines - Network checks
StringUtils.java        // 50 lines - String operations
ImageUtils.java         // 80 lines - Image processing

// BAD: 6 levels of nesting
private void processBooking() {
    if (isUserLoggedIn()) {
        if (hasSelectedProvider()) {
            if (hasSelectedDate()) {
                if (hasSelectedTime()) {
                    if (hasPaymentMethod()) {
                        if (agreedToTerms()) {
                            // Finally do the actual work
                            submitBooking();
                        } else {
                            showError("Please agree to terms");
                        }
                    } else {
                        showError("Please select payment method");
                    }
                } else {
                    showError("Please select time");
                }
            } else {
                showError("Please select date");
            }
        } else {
            showError("Please select provider");
        }
    } else {
        showError("Please log in");
    }
}

// GOOD: Early returns, no nesting
private void processBooking() {
    if (!isUserLoggedIn()) {
        showError("Please log in");
        return;
    }
    if (!hasSelectedProvider()) {
        showError("Please select provider");
        return;
    }
    if (!hasSelectedDate()) {
        showError("Please select date");
        return;
    }
    if (!hasSelectedTime()) {
        showError("Please select time");
        return;
    }
    if (!hasPaymentMethod()) {
        showError("Please select payment method");
        return;
    }
    if (!agreedToTerms()) {
        showError("Please agree to terms");
        return;
    }

    submitBooking();
}

// BAD: What does 10 mean?
if (retryCount > 10) {
    stopRetrying();
}

// BAD: What are these dimensions?
imageView.setLayoutParams(new LayoutParams(500, 300));

// BAD: What's this timeout?
handler.postDelayed(runnable, 5000);

// GOOD: Named constants
private static final int MAX_RETRY_COUNT = 10;
private static final int IMAGE_WIDTH_DP = 500;
private static final int IMAGE_HEIGHT_DP = 300;
private static final int RETRY_DELAY_MS = 5000;

if (retryCount > MAX_RETRY_COUNT) {
    stopRetrying();
}

// DuplicatedAdapter pattern (appears in 20+ adapters)

// CarePListAdapter.java
@Override
public void onBindViewHolder(ViewHolder holder, int position) {
    CarePDataModel provider = providerList.get(position);
    holder.tvName.setText(provider.getFirstName() + " " + provider.getLastName());
    holder.tvSpecialty.setText(provider.getSpecialty());
    holder.tvRating.setText(String.valueOf(provider.getRating()));

    if (provider.getImageUrl() != null && !provider.getImageUrl().isEmpty()) {
        Glide.with(context)
            .load(provider.getImageUrl())
            .placeholder(R.drawable.placeholder_profile)
            .error(R.drawable.error_image)
            .into(holder.ivProfile);
    } else {
        holder.ivProfile.setImageResource(R.drawable.placeholder_profile);
    }

    holder.itemView.setOnClickListener(v -> {
        clickListener.onItemClick(position, provider);
    });
}

// BlogAdapter.java - NEARLY IDENTICAL
@Override
public void onBindViewHolder(ViewHolder holder, int position) {
    BlogModel blog = blogList.get(position);
    holder.tvTitle.setText(blog.getTitle());
    holder.tvDescription.setText(blog.getDescription());
    holder.tvDate.setText(blog.getPublishDate());

    if (blog.getImageUrl() != null && !blog.getImageUrl().isEmpty()) {
        Glide.with(context)
            .load(blog.getImageUrl())
            .placeholder(R.drawable.placeholder_blog)
            .error(R.drawable.error_image)
            .into(holder.ivBlog);
    } else {
        holder.ivBlog.setImageResource(R.drawable.placeholder_blog);
    }

    holder.itemView.setOnClickListener(v -> {
        clickListener.onItemClick(position, blog);
    });
}

// ... repeated 18 more times in other adapters

public abstract class BaseRecyclerAdapter<T, VH extends RecyclerView.ViewHolder> 
    extends RecyclerView.Adapter<VH> {

    protected List<T> items;
    protected Context context;
    protected OnItemClickListener<T> clickListener;

    protected void loadImage(String url, ImageView imageView, int placeholder) {
        if (url != null && !url.isEmpty()) {
            Glide.with(context)
                .load(url)
                .placeholder(placeholder)
                .error(R.drawable.error_image)
                .into(imageView);
        } else {
            imageView.setImageResource(placeholder);
        }
    }

    protected void setItemClickListener(View itemView, int position, T item) {
        itemView.setOnClickListener(v -> clickListener.onItemClick(position, item));
    }
}

// BAD: Nested callbacks
AndroidNetworking.post(Utils.BaseURL + "Authenticate")
    .addJSONObjectBody(loginJson)
    .build()
    .getAsJSONObject(new JSONObjectRequestListener() {
        @Override
        public void onResponse(JSONObject response) {
            String userId = response.getString("userLoginInfoId");

            // Nested callback 1
            AndroidNetworking.get(Utils.BaseURL + "GetUserProfile")
                .addQueryParameter("userId", userId)
                .build()
                .getAsJSONObject(new JSONObjectRequestListener() {
                    @Override
                    public void onResponse(JSONObject profile) {
                        String imageUrl = profile.getString("imageUrl");

                        // Nested callback 2
                        Glide.with(context)
                            .load(imageUrl)
                            .listener(new RequestListener<Drawable>() {
                                @Override
                                public boolean onLoadFailed(...) {
                                    // Handle error
                                    return false;
                                }

                                @Override
                                public boolean onResourceReady(...) {
                                    // Nested callback 3
                                    connectWebSocket(userId, new WebSocketCallback() {
                                        @Override
                                        public void onConnected() {
                                            // Finally navigate to home
                                            navigateToHome();
                                        }

                                        @Override
                                        public void onError(Exception e) {
                                            // Handle error
                                        }
                                    });
                                    return false;
                                }
                            })
                            .into(imageView);
                    }

                    @Override
                    public void onError(ANError error) {
                        // Handle error
                    }
                });
        }

        @Override
        public void onError(ANError error) {
            // Handle error
        }
    });

// GOOD: Flat structure with RxJava
login(username, password)
    .flatMap(userId -> getUserProfile(userId))
    .flatMap(profile -> loadImage(profile.getImageUrl()))
    .flatMap(drawable -> connectWebSocket(userId))
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(
        result -> navigateToHome(),
        error -> handleError(error)
    );

// BAD: Using primitives for everything
void createAppointment(String providerId, String date, String time, 
                      String duration, double price, String currency) {
    // ...
}

// Easy to mix up parameters
createAppointment("123", "2025-11-06", "500", "10:00", "SAR", 50.0); // BUG!

// GOOD: Use value objects
class ProviderId {
    private final String value;
    // validation, equals, hashCode
}

class AppointmentTime {
    private final LocalDate date;
    private final LocalTime time;
    // validation, formatting
}

class Money {
    private final double amount;
    private final Currency currency;
    // operations, formatting
}

void createAppointment(ProviderId providerId, AppointmentTime time, 
                      Duration duration, Money price) {
    // Type-safe!
}

// Create ApiClient class
public class ApiClient {
    public Single<UserProfile> getUserProfile(String userId) {
        return AndroidNetworking.get(ApiEndpoints.GET_USER_PROFILE)
            .addQueryParameter("userId", userId)
            .build()
            .getJSONObjectSingle()
            .map(json -> new UserProfile(json));
    }
}

// Now only ONE place to change

// BAD: Direct static dependency (in 500+ places)
if (Utils.isNetworkAvailable(context)) {
    String formatted = Utils.formatDate(dateString);
    Utils.showToast(context, "Success: " + formatted);
}

// GOOD: Injected dependencies
public class MyActivity extends AppCompatActivity {
    private NetworkChecker networkChecker;
    private DateFormatter dateFormatter;
    private UiHelper uiHelper;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Inject dependencies (manual or via Dagger/Hilt)
        networkChecker = new NetworkChecker(this);
        dateFormatter = new DateFormatter();
        uiHelper = new UiHelper(this);
    }

    private void doWork() {
        if (networkChecker.isNetworkAvailable()) {
            String formatted = dateFormatter.format(dateString);
            uiHelper.showToast("Success: " + formatted);
        }
    }
}

Duplication Breakdown:
├─ Exact Clones:        ~5%  (Copy-paste code)
├─ Similar Structures:  ~7%  (Same pattern, different names)
└─ Type 3 Clones:       ~3%  (Modified copies)

// Repeated 300+ times with minor variations
AndroidNetworking.post(url)
    .addHeaders("Authorization", "Bearer " + token)
    .addHeaders("Content-Type", "application/json")
    .addJSONObjectBody(jsonObject)
    .setPriority(Priority.MEDIUM)
    .build()
    .getAsJSONObject(new JSONObjectRequestListener() {
        @Override
        public void onResponse(JSONObject response) {
            try {
                if (response.getBoolean("success")) {
                    // Success handling
                } else {
                    // Error handling
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onError(ANError error) {
            hideProgressDialog();
            showError(error.getMessage());
        }
    });

// Repeated everywhere
} catch (Exception e) {
    e.printStackTrace();
}

// Or
} catch (Exception e) {
    e.printStackTrace();
    showError("Something went wrong");
}

// Repeated pattern
if (imageUrl != null && !imageUrl.isEmpty()) {
    Glide.with(context)
        .load(imageUrl)
        .placeholder(R.drawable.placeholder)
        .error(R.drawable.error)
        .into(imageView);
} else {
    imageView.setImageResource(R.drawable.placeholder);
}

// BAD: Loads everything
AndroidNetworking.get(Utils.BaseURL + "GetAllProviders")
    .build()
    .getAsJSONArray(new JSONArrayRequestListener() {
        @Override
        public void onResponse(JSONArray response) {
            // Loads 1000+ providers into memory
            for (int i = 0; i < response.length(); i++) {
                providerList.add(new CarePDataModel(response.getJSONObject(i)));
            }
            adapter.notifyDataSetChanged(); // Updates all at once
        }
    });

// GOOD: Pagination
public class ProviderPagingSource extends PagingSource<Integer, CarePDataModel> {
    private static final int PAGE_SIZE = 20;

    @Override
    public Single<LoadResult<Integer, CarePDataModel>> loadSingle(LoadParams<Integer> params) {
        int page = params.getKey() != null ? params.getKey() : 0;

        return apiClient.getProviders(page, PAGE_SIZE)
            .map(providers -> new LoadResult.Page<>(
                providers,
                page == 0 ? null : page - 1,
                providers.isEmpty() ? null : page + 1
            ))
            .onErrorReturn(LoadResult.Error::new);
    }
}

// Configure Glide globally
@GlideModule
public class MyGlideModule extends AppGlideModule {
    @Override
    public void applyOptions(Context context, GlideBuilder builder) {
        builder.setMemoryCache(new LruResourceCache(50 * 1024 * 1024)); // 50MB
        builder.setDiskCache(new InternalCacheDiskCacheFactory(context, 
            100 * 1024 * 1024)); // 100MB
    }
}

// BAD: JSON parsing blocks UI
@Override
public void onTextMessage(WebSocket ws, String message) {
    try {
        JSONObject json = new JSONObject(message); // Blocks UI!
        String messageType = json.getString("type");
        // ... process message
    } catch (JSONException e) {
        e.printStackTrace();
    }
}

// GOOD: Parse on background thread
@Override
public void onTextMessage(WebSocket ws, String message) {
    executorService.execute(() -> {
        try {
            JSONObject json = new JSONObject(message);
            String messageType = json.getString("type");

            // Post to main thread for UI updates
            handler.post(() -> processMessage(json));
        } catch (JSONException e) {
            Timber.e(e);
        }
    });
}

// BAD: Activity leaked
AndroidNetworking.get(url)
    .build()
    .getAsJSONObject(new JSONObjectRequestListener() {
        @Override
        public void onResponse(JSONObject response) {
            // This holds reference to Activity
            updateUI(response); // Activity may be destroyed!
        }
    });

// GOOD: WeakReference
private static class SafeListener extends JSONObjectRequestListener {
    private WeakReference<MyActivity> activityRef;

    SafeListener(MyActivity activity) {
        activityRef = new WeakReference<>(activity);
    }

    @Override
    public void onResponse(JSONObject response) {
        MyActivity activity = activityRef.get();
        if (activity != null && !activity.isFinishing()) {
            activity.updateUI(response);
        }
    }
}

// BAD: Resources leaked
@Override
protected void onDestroy() {
    super.onDestroy();
    // WebRTC objects not cleaned up!
}

// GOOD: Proper cleanup
@Override
protected void onDestroy() {
    super.onDestroy();

    if (localVideoTrack != null) {
        localVideoTrack.dispose();
        localVideoTrack = null;
    }

    if (localAudioTrack != null) {
        localAudioTrack.dispose();
        localAudioTrack = null;
    }

    if (peerConnection != null) {
        peerConnection.dispose();
        peerConnection = null;
    }

    if (videoCapturer != null) {
        try {
            videoCapturer.stopCapture();
        } catch (InterruptedException e) {
            Timber.e(e);
        }
        videoCapturer.dispose();
        videoCapturer = null;
    }

    if (peerConnectionFactory != null) {
        peerConnectionFactory.dispose();
        peerConnectionFactory = null;
    }

    if (rootEglBase != null) {
        rootEglBase.release();
        rootEglBase = null;
    }
}

// BAD: Swallows all exceptions
try {
    // Complex operation
    processPayment();
    updateDatabase();
    sendNotification();
} catch (Exception e) {
    e.printStackTrace(); // Only prints to logcat
    // User never knows what went wrong!
}

// GOOD: Specific exception handling
try {
    processPayment();
} catch (PaymentException e) {
    Timber.e(e, "Payment failed");
    showError("Payment failed. Please check your card details.");
    FirebaseCrashlytics.getInstance().recordException(e);
} catch (NetworkException e) {
    Timber.e(e, "Network error during payment");
    showError("Network error. Please check your connection and try again.");
} catch (Exception e) {
    Timber.e(e, "Unexpected error during payment");
    showError("An unexpected error occurred. Please contact support.");
    FirebaseCrashlytics.getInstance().recordException(e);
}

// BAD: User left wondering
@Override
public void onError(ANError error) {
    error.printStackTrace(); // Only in logcat
    hideProgressDialog();
    // User sees nothing!
}

// GOOD: Inform user
@Override
public void onError(ANError error) {
    hideProgressDialog();

    String userMessage = ErrorMessageHelper.getUserFriendlyMessage(error);
    showError(userMessage);

    // Log for debugging
    Timber.e(error.getCause(), "API Error: %s", error.getErrorDetail());

    // Track in Crashlytics
    FirebaseCrashlytics.getInstance().log("API Error: " + error.getErrorDetail());
}

// BAD: One shot, no retry
makeApiCall();

// GOOD: Retry with exponential backoff
makeApiCallWithRetry(3, 1000); // 3 retries, 1 second base delay

private void makeApiCallWithRetry(int maxRetries, long baseDelay) {
    new RetryHelper(maxRetries, baseDelay)
        .retry(() -> apiClient.makeCall())
        .subscribe(
            result -> handleSuccess(result),
            error -> handleFinalFailure(error)
        );
}