Android-pyApi/android_pyapi/android/content_sync.py

"""
Android Content Sync API — SyncManager, SyncAdapter, SyncResult, SyncRequest, ContentResolver, etc.
方法签名完全对齐 Android SDK
"""

from __future__ import annotations

import os
import sys
import time
import json
import uuid
import threading
from datetime import datetime, timedelta
from typing import Any, Dict, List, Optional, Set, Tuple, Callable

from .._core import Stub, AndroidOnlyError
from ..java.lang import RuntimeException

IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {})


# ═══════════════════════════════════════════════════════════════
# 常量
# ═══════════════════════════════════════════════════════════════

# SYNC_* 常量
SYNC_EXTRAS_REQUIRE_CHARGING = "require_charging"
SYNC_EXTRAS_UPLOAD = "upload"
SYNC_EXTRAS_MANUAL = "force"
SYNC_EXTRAS_IGNORE_BACKOFF = "ignore_backoff"
SYNC_EXTRAS_DO_NOT_RETRY = "do_not_retry"
SYNC_EXTRAS_DISCARD_LOCAL_DELETIONS = "discard_local_deletions"
SYNC_EXTRAS_EXPEDITED = "expedited"
SYNC_EXTRAS_SCHEDULE_AS_EXPEDITED = "schedule_as_expedited"
SYNC_EXTRAS_OVERRIDE_TOO_MANY_DELETIONS = "override_too_many_deletions"
SYNC_EXTRAS_ALLOW_METERED = "allow_metered"
SYNC_EXTRAS_INITIALIZE = "initialize"
SYNC_EXTRAS_VIRTUAL_EXTRAS = "virtual_extras"
SYNC_EXTRAS_IGNORE_SETTINGS = "ignore_settings"
SYNC_EXTRAS_IS_EXPEDITED = "is_expedited"
SYNC_EXTRAS_IS_RETRY = "is_retry"

# SYNC_ERROR 常量
SYNC_ERROR_SYNC_ALREADY_IN_PROGRESS = 1
SYNC_ERROR_AUTHENTICATION = 2
SYNC_ERROR_IO = 3
SYNC_ERROR_PARSE = 4
SYNC_ERROR_CONFLICT = 5
SYNC_ERROR_TOO_MANY_DELETIONS = 6
SYNC_ERROR_TOO_MANY_RETRIES = 7
SYNC_ERROR_INTERNAL = 8
SYNC_ERROR_SYNC_EXTRAS_INVALID = 9
SYNC_ERROR_REMOTE_SERVER_ERROR = 10
SYNC_ERROR_MISMATCHED_UID = 11
SYNC_ERROR_USER_CANCELED = 12

# 通知码
NOTIFY_SYNC_RESULT = 0
NOTIFY_SETTINGS_CHANGE = 1
NOTIFY_SYNC_START = 2
NOTIFY_SYNC_STOP = 3

# 同步触发器
SYNC_TRIGGER_MANUAL = 0
SYNC_TRIGGER_AUTO = 1
SYNC_TRIGGER_EXPEDITED = 2
SYNC_TRIGGER_SCHEDULED = 3

# 同步状态
SYNC_STATUS_PENDING = 0
SYNC_STATUS_IN_PROGRESS = 1
SYNC_STATUS_SUCCESS = 2
SYNC_STATUS_ERROR = 3
SYNC_STATUS_CANCELLED = 4


# ═══════════════════════════════════════════════════════════════
# SyncResult
# ═══════════════════════════════════════════════════════════════

class SyncResult(Stub):
    """SyncResult — 同步结果"""

    def __init__(self):
        super().__init__()
        self.syncAlreadlyInProgress = False
        self.tooManyDeletions = False
        self.tooManyRetries = False
        self.databaseError = False
        self.fullSyncRequested = False
        self.partialSyncUnavailable = False
        self.moreRecordsToGet = False
        self.delayUntil = 0
        self.stats: "SyncStats" = SyncStats()
        self._sync_error = 0
        self._sync_exception: Optional[Exception] = None
        self._sync_start_time: Optional[float] = None
        self._sync_end_time: Optional[float] = None
        self._sync_duration_ms: Optional[int] = None
        self._num_conflicts = 0
        self._num_auth_exceptions = 0
        self._num_io_exceptions = 0
        self._num_parse_exceptions = 0
        self._num_skipped_entries = 0
        self._num_inserted_entries = 0
        self._num_updated_entries = 0
        self._num_deleted_entries = 0
        self._has_error = False
        self._has_hard_error = False
        self._has_soft_error = False

    def hasError(self) -> bool:
        return (
            self.syncAlreadlyInProgress
            or self.tooManyDeletions
            or self.tooManyRetries
            or self.databaseError
            or self.stats.numAuthExceptions > 0
            or self.stats.numIoExceptions > 0
            or self.stats.numParseExceptions > 0
            or self._has_error
        )

    def hasHardError(self) -> bool:
        return (
            self.tooManyDeletions
            or self.databaseError
            or self.stats.numAuthExceptions > 0
            or self.stats.numParseExceptions > 0
        )

    def hasSoftError(self) -> bool:
        return (
            self.syncAlreadlyInProgress
            or self.tooManyRetries
            or self.stats.numIoExceptions > 0
        )

    def clear(self) -> None:
        self.syncAlreadlyInProgress = False
        self.tooManyDeletions = False
        self.tooManyRetries = False
        self.databaseError = False
        self.fullSyncRequested = False
        self.partialSyncUnavailable = False
        self.moreRecordsToGet = False
        self.delayUntil = 0
        self.stats.clear()
        self._has_error = False
        self._has_hard_error = False
        self._has_soft_error = False

    def getStats(self) -> "SyncStats":
        return self.stats

    def toString(self) -> str:
        return (
            f"SyncResult(hasError={self.hasError()}, "
            f"fullSyncRequested={self.fullSyncRequested}, "
            f"moreRecordsToGet={self.moreRecordsToGet}, "
            f"stats={self.stats})"
        )


# ═══════════════════════════════════════════════════════════════
# SyncStats
# ═══════════════════════════════════════════════════════════════

class SyncStats(Stub):
    """SyncStats — 同步统计"""

    def __init__(self):
        super().__init__()
        self.numAuthExceptions = 0
        self.numIoExceptions = 0
        self.numParseExceptions = 0
        self.numConflictDetectedExceptions = 0
        self.numSkippedEntries = 0
        self.numInserts = 0
        self.numUpdates = 0
        self.numDeletes = 0
        self.numEntries = 0
        self._total_entries = 0
        self._total_errors = 0
        self._total_bytes_downloaded = 0
        self._total_bytes_uploaded = 0
        self._sync_duration_ms = 0

    def clear(self) -> None:
        self.numAuthExceptions = 0
        self.numIoExceptions = 0
        self.numParseExceptions = 0
        self.numConflictDetectedExceptions = 0
        self.numSkippedEntries = 0
        self.numInserts = 0
        self.numUpdates = 0
        self.numDeletes = 0
        self.numEntries = 0
        self._total_bytes_downloaded = 0
        self._total_bytes_uploaded = 0
        self._sync_duration_ms = 0

    def getTotalBytesDownloaded(self) -> int:
        return self._total_bytes_downloaded

    def setTotalBytesDownloaded(self, bytes_: int) -> None:
        self._total_bytes_downloaded = bytes_

    def getTotalBytesUploaded(self) -> int:
        return self._total_bytes_uploaded

    def setTotalBytesUploaded(self, bytes_: int) -> None:
        self._total_bytes_uploaded = bytes_

    def getSyncDurationMs(self) -> int:
        return self._sync_duration_ms

    def setSyncDurationMs(self, ms: int) -> None:
        self._sync_duration_ms = ms

    def toString(self) -> str:
        return (
            f"SyncStats(inserts={self.numInserts}, updates={self.numUpdates}, "
            f"deletes={self.numDeletes}, errors={self._total_errors})"
        )


# ═══════════════════════════════════════════════════════════════
# SyncInfo
# ═══════════════════════════════════════════════════════════════

class SyncInfo(Stub):
    """SyncInfo — 同步信息"""

    def __init__(self, authority: str, account: Any, userId: int):
        super().__init__()
        self._authority = authority
        self._account = account
        self._user_id = userId
        self._start_time = time.time()
        self._status = SYNC_STATUS_PENDING
        self._sync_id = str(uuid.uuid4())
        self._elapsed_time_ms = 0
        self._result: Optional[SyncResult] = None
        self._description: Optional[str] = None
        self._is_manual = False
        self._is_expedited = False
        self._trigger = SYNC_TRIGGER_AUTO
        self._sync_request: Optional["SyncRequest"] = None

    def getAuthority(self) -> str:
        return self._authority

    def getAccount(self) -> Any:
        return self._account

    def getUserId(self) -> int:
        return self._user_id

    def getStartTime(self) -> float:
        return self._start_time

    def getStatus(self) -> int:
        return self._status

    def setStatus(self, status: int) -> None:
        self._status = status

    def getSyncId(self) -> str:
        return self._sync_id

    def getElapsedTimeMs(self) -> int:
        return self._elapsed_time_ms

    def getResult(self) -> Optional[SyncResult]:
        return self._result

    def isManual(self) -> bool:
        return self._is_manual

    def isExpedited(self) -> bool:
        return self._is_expedited

    def getTriggerSource(self) -> int:
        return self._trigger

    def toString(self) -> str:
        return f"SyncInfo(authority={self._authority}, status={self._status})"


# ═══════════════════════════════════════════════════════════════
# SyncStatusObserver
# ═══════════════════════════════════════════════════════════════

class SyncStatusObserver(Stub):
    """SyncStatusObserver — 同步状态观察者"""

    def __init__(self):
        super().__init__()

    def onStatusChanged(self, which: int) -> None:
        pass

    def toString(self) -> str:
        return "SyncStatusObserver"


# ═══════════════════════════════════════════════════════════════
# SyncAdapter
# ═══════════════════════════════════════════════════════════════

class SyncAdapter(Stub):
    """SyncAdapter — 同步适配器基类"""

    def __init__(self, context: Any, autoInitialize: bool, allowParallelSyncs: bool):
        super().__init__()
        self._context = context
        self._auto_initialize = autoInitialize
        self._allow_parallel_syncs = allowParallelSyncs
        self._sync_auto_initialized = False
        self._is_initialized = False
        self._options: Dict[str, Any] = {}

    def onPerformSync(
        self,
        account: Any,
        extras: Any,
        authority: str,
        provider: Any,
        syncResult: SyncResult,
    ) -> None:
        pass

    def onSyncCanceled(self) -> None:
        pass

    def onSecurityException(self, account: Any, authority: str, exception: Any) -> None:
        pass

    def onUnsyncableAccount(self) -> bool:
        return True

    def getAutoInitialize(self) -> bool:
        return self._auto_initialize

    def getAllowParallelSyncs(self) -> bool:
        return self._allow_parallel_syncs

    def isSyncAdapterInitialized(self) -> bool:
        return self._is_initialized

    def toString(self) -> str:
        return f"SyncAdapter(auto_init={self._auto_initialize}, parallel={self._allow_parallel_syncs})"


# ═══════════════════════════════════════════════════════════════
# SyncRequest
# ═══════════════════════════════════════════════════════════════

class SyncRequest(Stub):
    """SyncRequest — 同步请求"""

    def __init__(self):
        super().__init__()
        self._account: Optional[Any] = None
        self._authority: Optional[str] = None
        self._extras: Dict[str, Any] = {}
        self._sync_flexibility_time = 0
        self._sync_run_time = 0
        self._is_expedited = False
        self._is_manual = False
        self._is_periodic = False
        self._ignore_backoff = False
        self._ignore_settings = False
        self._do_not_retry = False
        self._require_charging = False
        self._is_initialized = False
        self._schedule_as_expedited = False
        self._allow_metered = False
        self._discard_local_deletions = False
        self._override_too_many_deletions = False

    def getAccount(self) -> Optional[Any]:
        return self._account

    def getAuthority(self) -> Optional[str]:
        return self._authority

    def getExtras(self) -> Dict[str, Any]:
        return dict(self._extras)

    def isExpedited(self) -> bool:
        return self._is_expedited

    def isPeriodic(self) -> bool:
        return self._is_periodic

    def getSyncFlexibilityTime(self) -> int:
        return self._sync_flexibility_time

    def getSyncRunTime(self) -> int:
        return self._sync_run_time

    def toString(self) -> str:
        return f"SyncRequest(authority={self._authority}, periodic={self._is_periodic})"

    # ═══════════════════════════════════════════════════════════
    # SyncRequest.Builder
    # ═══════════════════════════════════════════════════════════

    class Builder(Stub):
        """SyncRequest.Builder — 同步请求构建器"""

        def __init__(self):
            super().__init__()
            self._request = SyncRequest()

        def sync(self) -> "SyncRequest.Builder":
            return self

        def setExpedited(self, expedited: bool) -> "SyncRequest.Builder":
            self._request._is_expedited = expedited
            return self

        def setManual(self, manual: bool) -> "SyncRequest.Builder":
            self._request._is_manual = manual
            return self

        def setExtras(self, extras: Dict[str, Any]) -> "SyncRequest.Builder":
            self._request._extras = dict(extras)
            return self

        def setIgnoreBackoff(self, ignoreBackoff: bool) -> "SyncRequest.Builder":
            self._request._ignore_backoff = ignoreBackoff
            return self

        def setIgnoreSettings(self, ignoreSettings: bool) -> "SyncRequest.Builder":
            self._request._ignore_settings = ignoreSettings
            return self

        def setDoNotRetry(self, doNotRetry: bool) -> "SyncRequest.Builder":
            self._request._do_not_retry = doNotRetry
            return self

        def setRequireCharging(self, requireCharging: bool) -> "SyncRequest.Builder":
            self._request._require_charging = requireCharging
            return self

        def setScheduleAsExpedited(self, expedited: bool) -> "SyncRequest.Builder":
            self._request._schedule_as_expedited = expedited
            return self

        def setAllowMetered(self, allowMetered: bool) -> "SyncRequest.Builder":
            self._request._allow_metered = allowMetered
            return self

        def setDiscardLocalDeletions(self, discard: bool) -> "SyncRequest.Builder":
            self._request._discard_local_deletions = discard
            return self

        def setOverrideTooManyDeletions(self, override: bool) -> "SyncRequest.Builder":
            self._request._override_too_many_deletions = override
            return self

        def setSyncAdapter(self, account: Any, authority: str) -> "SyncRequest.Builder":
            self._request._account = account
            self._request._authority = authority
            return self

        def setPeriodic(self, pollFrequency: int, flexTime: int = 0) -> "SyncRequest.Builder":
            self._request._is_periodic = True
            self._request._sync_run_time = time.time() + pollFrequency
            self._request._sync_flexibility_time = flexTime
            return self

        def build(self) -> SyncRequest:
            return self._request

        def toString(self) -> str:
            return f"SyncRequest.Builder(existing={self._request})"


# ═══════════════════════════════════════════════════════════════
# SyncConfiguration
# ═══════════════════════════════════════════════════════════════

class SyncConfiguration(Stub):
    """SyncConfiguration — 同步配置"""

    def __init__(self, authority: str, account: Any, userId: int = 0):
        super().__init__()
        self._authority = authority
        self._account = account
        self._user_id = userId
        self._sync_enabled = True
        self._sync_automatically = True
        self._sync_interval = 3600
        self._sync_flex = 300
        self._is_active = False
        self._pending = False
        self._last_sync_time: Optional[float] = None
        self._last_sync_result: Optional[SyncResult] = None
        self._delay_until = 0
        self._backoff_time = 0
        self._backoff_delay = 0
        self._authority_settings: Dict[str, Any] = {}

    def getAuthority(self) -> str:
        return self._authority

    def getAccount(self) -> Any:
        return self._account

    def getUserId(self) -> int:
        return self._user_id

    def isSyncEnabled(self) -> bool:
        return self._sync_enabled

    def setSyncEnabled(self, enabled: bool) -> None:
        self._sync_enabled = enabled

    def isSyncAutomatically(self) -> bool:
        return self._sync_automatically

    def setSyncAutomatically(self, auto: bool) -> None:
        self._sync_automatically = auto

    def getSyncInterval(self) -> int:
        return self._sync_interval

    def setSyncInterval(self, intervalSec: int) -> None:
        self._sync_interval = intervalSec

    def getSyncFlex(self) -> int:
        return self._sync_flex

    def setSyncFlex(self, flexSec: int) -> None:
        self._sync_flex = flexSec

    def getDelayUntil(self) -> int:
        return self._delay_until

    def setDelayUntil(self, delayUntil: int) -> None:
        self._delay_until = delayUntil

    def getLastSyncTime(self) -> Optional[float]:
        return self._last_sync_time

    def setLastSyncTime(self, syncTime: float) -> None:
        self._last_sync_time = syncTime

    def isActive(self) -> bool:
        return self._is_active

    def isPending(self) -> bool:
        return self._pending

    def toString(self) -> str:
        return f"SyncConfiguration(authority={self._authority}, enabled={self._sync_enabled})"


# ═══════════════════════════════════════════════════════════════
# SyncAdaptersCache
# ═══════════════════════════════════════════════════════════════

class SyncAdaptersCache(Stub):
    """SyncAdaptersCache — 同步适配器缓存"""

    def __init__(self):
        super().__init__()
        self._adapters: Dict[str, SyncAdapter] = {}
        self._configs: Dict[str, SyncConfiguration] = {}
        self._lock = threading.Lock()

    def put(self, authority: str, adapter: SyncAdapter) -> None:
        with self._lock:
            self._adapters[authority] = adapter

    def get(self, authority: str) -> Optional[SyncAdapter]:
        with self._lock:
            return self._adapters.get(authority)

    def remove(self, authority: str) -> None:
        with self._lock:
            self._adapters.pop(authority, None)

    def containsAuthority(self, authority: str) -> bool:
        with self._lock:
            return authority in self._adapters

    def getAuthorities(self) -> List[str]:
        with self._lock:
            return list(self._adapters.keys())

    def getAdapterCount(self) -> int:
        with self._lock:
            return len(self._adapters)

    def clear(self) -> None:
        with self._lock:
            self._adapters.clear()

    def getConfiguration(self, authority: str) -> Optional[SyncConfiguration]:
        with self._lock:
            return self._configs.get(authority)

    def putConfiguration(self, config: SyncConfiguration) -> None:
        with self._lock:
            self._configs[config.getAuthority()] = config

    def getAllConfigurations(self) -> List[SyncConfiguration]:
        with self._lock:
            return list(self._configs.values())

    def toString(self) -> str:
        with self._lock:
            return f"SyncAdaptersCache(adapters={len(self._adapters)}, configs={len(self._configs)})"


# ═══════════════════════════════════════════════════════════════
# SyncManager
# ═══════════════════════════════════════════════════════════════

class SyncManager(Stub):
    """SyncManager — 同步管理器 (桌面存根)"""

    def __init__(self, context: Any = None):
        super().__init__()
        self._context = context
        self._lock = threading.Lock()
        self._active_syncs: Dict[str, SyncInfo] = {}
        self._pending_syncs: List[SyncRequest] = []
        self._observers: List[SyncStatusObserver] = []
        self._adapters_cache = SyncAdaptersCache()
        self._sync_automatically = True
        self._master_sync_automatically = True
        self._sync_enabled = True
        self._is_syncable = True
        self._sync_backoff_enabled = True
        self._worker_thread: Optional[threading.Thread] = None
        self._running = True
        self._pending_sync_count = 0
        self._total_sync_count = 0
        self._last_sync_time: Optional[float] = None
        self._start_worker()

    def _start_worker(self) -> None:
        if self._worker_thread is None or not self._worker_thread.is_alive():
            self._running = True
            self._worker_thread = threading.Thread(target=self._sync_loop, daemon=True)
            self._worker_thread.start()

    def _sync_loop(self) -> None:
        while self._running:
            with self._lock:
                if self._pending_syncs:
                    req = self._pending_syncs.pop(0)
                    self._execute_sync(req)
            time.sleep(1.0)

    def _execute_sync(self, request: SyncRequest) -> None:
        authority = request.getAuthority()
        if authority:
            info = SyncInfo(authority, request._account, 0)
            self._active_syncs[authority] = info
            self._total_sync_count += 1
            adapter = self._adapters_cache.get(authority)
            if adapter:
                result = SyncResult()
                try:
                    adapter.onPerformSync(
                        request._account, request._extras, authority, None, result
                    )
                except Exception:
                    pass
                info._result = result
            time.sleep(0.1)
            self._active_syncs.pop(authority, None)
            self._last_sync_time = time.time()

    def getSyncableAccountsForAuthority(self, authority: str) -> List[Any]:
        return []

    def getSyncableAccounts(self) -> List[Any]:
        return []

    def scheduleSync(self, request: SyncRequest) -> None:
        with self._lock:
            self._pending_syncs.append(request)
            self._pending_sync_count = len(self._pending_syncs)

    def schedule(self, account: Any, authority: str, extras: Any) -> None:
        req = SyncRequest.Builder().setSyncAdapter(account, authority).build()
        self.scheduleSync(req)

    def cancelSync(self, request: SyncRequest) -> None:
        with self._lock:
            self._pending_syncs = [
                r for r in self._pending_syncs
                if r.getAuthority() != request.getAuthority()
            ]
            self._pending_sync_count = len(self._pending_syncs)

    def cancelSync(self, authority: str = None) -> None:
        with self._lock:
            if authority:
                self._pending_syncs = [
                    r for r in self._pending_syncs
                    if r.getAuthority() != authority
                ]
            else:
                self._pending_syncs.clear()
            self._pending_sync_count = len(self._pending_syncs)

    def getCurrentSyncs(self) -> List[SyncInfo]:
        with self._lock:
            return list(self._active_syncs.values())

    def getSyncAutomatically(self, account: Any, authority: str) -> bool:
        return self._sync_automatically

    def setSyncAutomatically(self, account: Any, authority: str, sync: bool) -> None:
        self._sync_automatically = sync

    def getMasterSyncAutomatically(self) -> bool:
        return self._master_sync_automatically

    def setMasterSyncAutomatically(self, sync: bool) -> None:
        self._master_sync_automatically = sync

    def setIsSyncable(self, account: Any, authority: str, syncable: int) -> None:
        self._is_syncable = syncable != 0

    def getIsSyncable(self, account: Any, authority: str) -> int:
        return 1 if self._is_syncable else 0

    def addStatusChangeListener(self, which: int, observer: SyncStatusObserver) -> None:
        if observer not in self._observers:
            self._observers.append(observer)

    def removeStatusChangeListener(self, observer: SyncStatusObserver) -> None:
        if observer in self._observers:
            self._observers.remove(observer)

    def notifyStatusChange(self, which: int) -> None:
        for observer in self._observers:
            try:
                observer.onStatusChanged(which)
            except Exception:
                pass

    def getSyncAdapterTypes(self) -> List[Any]:
        return []

    def getSyncAdapterPackagesForAuthority(self, authority: str) -> List[str]:
        return []

    def isSyncActive(self, account: Any, authority: str) -> bool:
        with self._lock:
            return authority in self._active_syncs

    def isSyncPending(self, account: Any, authority: str) -> bool:
        with self._lock:
            for req in self._pending_syncs:
                if req.getAuthority() == authority:
                    return True
            return False

    def getSyncInfo(self, authority: str) -> Optional[SyncInfo]:
        with self._lock:
            return self._active_syncs.get(authority)

    def getAdaptersCache(self) -> SyncAdaptersCache:
        return self._adapters_cache

    def getTotalSyncCount(self) -> int:
        return self._total_sync_count

    def getLastSyncTime(self) -> Optional[float]:
        return self._last_sync_time

    def getPendingSyncCount(self) -> int:
        with self._lock:
            return len(self._pending_syncs)

    def toString(self) -> str:
        with self._lock:
            return (
                f"SyncManager(active={len(self._active_syncs)}, "
                f"pending={len(self._pending_syncs)}, "
                f"total={self._total_sync_count})"
            )


# ═══════════════════════════════════════════════════════════════
# ContentResolver (Sync 扩展)
# ═══════════════════════════════════════════════════════════════

class ContentResolverSync(Stub):
    """ContentResolver — 同步扩展方法"""

    SYNC_EXTRAS_REQUIRE_CHARGING = SYNC_EXTRAS_REQUIRE_CHARGING
    SYNC_EXTRAS_UPLOAD = SYNC_EXTRAS_UPLOAD
    SYNC_EXTRAS_MANUAL = SYNC_EXTRAS_MANUAL
    SYNC_EXTRAS_IGNORE_BACKOFF = SYNC_EXTRAS_IGNORE_BACKOFF
    SYNC_EXTRAS_DO_NOT_RETRY = SYNC_EXTRAS_DO_NOT_RETRY
    SYNC_EXTRAS_DISCARD_LOCAL_DELETIONS = SYNC_EXTRAS_DISCARD_LOCAL_DELETIONS
    SYNC_EXTRAS_EXPEDITED = SYNC_EXTRAS_EXPEDITED
    SYNC_EXTRAS_OVERRIDE_TOO_MANY_DELETIONS = SYNC_EXTRAS_OVERRIDE_TOO_MANY_DELETIONS
    SYNC_EXTRAS_ALLOW_METERED = SYNC_EXTRAS_ALLOW_METERED
    SYNC_EXTRAS_INITIALIZE = SYNC_EXTRAS_INITIALIZE
    SYNC_EXTRAS_IGNORE_SETTINGS = SYNC_EXTRAS_IGNORE_SETTINGS

    NOTIFY_SYNC_RESULT = NOTIFY_SYNC_RESULT
    NOTIFY_SETTINGS_CHANGE = NOTIFY_SETTINGS_CHANGE
    NOTIFY_SYNC_START = NOTIFY_SYNC_START
    NOTIFY_SYNC_STOP = NOTIFY_SYNC_STOP

    def __init__(self):
        super().__init__()

    @staticmethod
    def requestSync(account: Any, authority: str, extras: Any) -> None:
        pass

    @staticmethod
    def requestSync(request: SyncRequest) -> None:
        pass

    @staticmethod
    def cancelSync(request: SyncRequest) -> None:
        pass

    @staticmethod
    def cancelSync(account: Any, authority: str) -> None:
        pass

    @staticmethod
    def getSyncAdapterTypes() -> List[Any]:
        return []

    @staticmethod
    def getSyncAutomatically(account: Any, authority: str) -> bool:
        return True

    @staticmethod
    def setSyncAutomatically(account: Any, authority: str, sync: bool) -> None:
        pass

    @staticmethod
    def getMasterSyncAutomatically() -> bool:
        return True

    @staticmethod
    def setMasterSyncAutomatically(sync: bool) -> None:
        pass

    @staticmethod
    def isSyncActive(account: Any, authority: str) -> bool:
        return False

    @staticmethod
    def isSyncPending(account: Any, authority: str) -> bool:
        return False

    @staticmethod
    def addStatusChangeListener(which: int, observer: SyncStatusObserver) -> None:
        pass

    @staticmethod
    def removeStatusChangeListener(observer: SyncStatusObserver) -> None:
        pass

    @staticmethod
    def validateSyncExtrasBundle(extras: Any) -> None:
        pass

    @staticmethod
    def getPeriodicSyncs(account: Any, authority: str) -> List[SyncRequest]:
        return []

    @staticmethod
    def addPeriodicSync(account: Any, authority: str, extras: Any, pollFrequency: int) -> None:
        pass

    @staticmethod
    def removePeriodicSync(account: Any, authority: str, extras: Any) -> None:
        pass

    @staticmethod
    def setIsSyncable(account: Any, authority: str, syncable: int) -> None:
        pass

    @staticmethod
    def getIsSyncable(account: Any, authority: str) -> int:
        return 1

    @staticmethod
    def getSyncAdapterPackagesForAuthority(authority: str) -> List[str]:
        return []

    @staticmethod
    def invalidateSegments(authority: str) -> None:
        pass

    @staticmethod
    def wrapSyncExtras(extras: Any) -> Any:
        return extras

    def toString(self) -> str:
        return "ContentResolver(Sync)"

SyncRequest.Builder = SyncRequest.Builder