08. Refurbished Hardware

Refurbished and second-hand devices represent a significant market segment in African consumer electronics. These devices offer attractive price points but introduce reliability and support challenges that impact AI deployment strategies. Understanding this market enables cost optimization while managing operational risk.

Device sourcing pathways affect reliability outcomes. Manufacturer refurbished units from carriers or OEM programs provide quality assurance but at higher prices. Third-party refurbished devices offer lower costs but variable quality. Grey market devices may lack proper certification and support infrastructure. Each pathway involves different warranty terms and return policies.

Hardware inspection protocols reduce failure rates. Battery health testing identifies cells with reduced capacity—replacement before deployment prevents mid-session power failures. Storage benchmarking reveals devices with degraded flash memory that may corrupt data. Screen and touch sensor testing ensures usability. Thermal testing under load identifies cooling system failures that cause performance throttling.

# Hardware assessment for device qualification
import subprocess
import re
from dataclasses import dataclass
from typing import Optional

@dataclass
class DeviceProfile:
    total_ram_mb: int
    available_ram_mb: int
    storage_gb: float
    battery_health_percent: float
    cpu_model: str
    gpu_available: bool
    thermal_throttle_expected: bool

class DeviceAssessor:
    """Assess device capabilities for AI deployment."""
    
    def __init__(self, min_ram_mb: int = 1024, min_storage_gb: float = 4.0):
        self.min_ram = min_ram_mb
        self.min_storage = min_storage_gb
    
    def run_assessment(self, device_id: Optional[str] = None) -> dict:
        """Run thorough device assessment."""
        results = {
            'passed': True,
            'warnings': [],
            'errors': [],
            'profile': None
        }
        
        # RAM assessment
        ram_info = self._check_ram()
        results['profile'].total_ram_mb = ram_info['total']
        
        if ram_info['total'] < self.min_ram:
            results['passed'] = False
            results['errors'].append(
                f"Insufficient RAM: {ram_info['total']}MB < {self.min_ram}MB minimum"
            )
        
        # Storage assessment
        storage_info = self._check_storage()
        results['profile'].storage_gb = storage_info['available']
        
        if storage_info['available'] < self.min_storage:
            results['passed'] = False
            results['errors'].append(
                f"Insufficient storage: {storage_info['available']:.1f}GB < {self.min_storage}GB minimum"
            )
        
        # Battery assessment (Android)
        battery_info = self._check_battery()
        results['profile'].battery_health_percent = battery_info['health']
        
        if battery_info['health'] < 70:
            results['warnings'].append(
                f"Reduced battery capacity: {battery_info['health']}%"
            )
        
        # Thermal assessment
        thermal_info = self._check_thermal()
        results['profile'].thermal_throttle_expected = thermal_info['throttles']
        
        if thermal_info['throttles']:
            results['warnings'].append(
                "Thermal throttling expected under load"
            )
        
        return results
    
    def _check_ram(self) -> dict:
        """Query available RAM."""
        try:
            # Android via ADB
            result = subprocess.run(
                ['adb', '-s', self.device_id, 'shell', 'cat', '/proc/meminfo'],
                capture_output=True, text=True, timeout=5
            )
            memtotal = re.search(r'MemTotal:\s+(\d+)', result.stdout)
            memavailable = re.search(r'MemAvailable:\s+(\d+)', result.stdout)
            
            if memtotal and memavailable:
                return {
                    'total': int(memtotal.group(1)) // 1024,
                    'available': int(memavailable.group(1)) // 1024
                }
        except Exception:
            pass
        
        return {'total': 0, 'available': 0}
    
    def _check_battery(self) -> dict:
        """Query battery health via sysfs."""
        try:
            result = subprocess.run(
                ['adb', '-s', self.device_id, 'shell', 
                 'dumpsys battery'],
                capture_output=True, text=True, timeout=5
            )
            health = re.search(r'health:\s+(\d+)', result.stdout)
            level = re.search(r'level:\s+(\d+)', result.stdout)
            
            return {
                'health': int(health.group(1)) if health else 0,
                'level': int(level.group(1)) if level else 0
            }
        except Exception:
            return {'health': 0, 'level': 0}
    
    def _check_storage(self) -> dict:
        """Query storage availability."""
        try:
            result = subprocess.run(
                ['adb', '-s', self.device_id, 'shell', 
                 'df', '/data'],
                capture_output=True, text=True, timeout=5
            )
            available = re.search(r'(\d+)\s+\d+\s+\d+\s+(\d+)%', result.stdout)
            
            if available:
                return {'available': int(available.group(2)) / (1024*1024)}
        except Exception:
            pass
        
        return {'available': 0.0}
    
    def _check_thermal(self) -> dict:
        """Check thermal throttling status."""
        try:
            result = subprocess.run(
                ['adb', '-s', self.device_id, 'shell', 
                 'cat', '/sys/class/thermal/thermal_zone0/temp'],
                capture_output=True, text=True, timeout=5
            )
            temp = int(result.stdout.strip())
            
            return {
                'temp_celsius': temp / 1000,
                'throttles': temp > 45000  # Threshold for throttle
            }
        except Exception:
            return {'temp_celsius': 0, 'throttles': False}

Repair and refurbishment partnerships extend device lifespan. Local repair shops can replace batteries, screens, and storage at lower cost than device replacement. Volume procurement from certified refurbishers provides consistent quality. Device tracking systems monitor deployment health and trigger maintenance before failures impact users.

Device lifecycle management considers total cost beyond initial purchase. Battery replacement every 18-24 months maintains performance. Storage migration before flash wearout prevents data loss. Replacement scheduling based on observed failure rates optimizes refresh timing. Fleet management software tracks individual device health and automates maintenance scheduling.