PyObjC Framework CallKit

Warnings

• breaking PyObjC 12.0 dropped support for Python 3.9. Ensure your Python environment is 3.10 or newer to use this version of the library.
  Fix: Upgrade Python to 3.10 or later.
• breaking PyObjC 11.0 dropped support for Python 3.8. Users on PyObjC 11.x and later must use Python 3.9 or newer.
  Fix: Upgrade Python to 3.9 or later.
• breaking PyObjC 10.3 introduced a change where `__init__` could not be used when the class used the PyObjC-provided `__new__` (i.e., didn't define its own `__new__`). This was partially reverted in 10.3.1 but could still affect code on 10.3.0.
  Fix: Upgrade to PyObjC 10.3.1 or later, or ensure your Python classes implement their own `__new__` if they rely on `__init__` in conjunction with `objc.super`.
• gotcha PyObjC 11.1 aligned the core bridge's Automatic Reference Counting (ARC) behavior for 'init' family methods (e.g., `alloc().init()`) to correctly model that they steal a reference to self and return a new one. This change in memory management semantics could affect existing code that relies on previous PyObjC behavior around initializers.
  Fix: Review code interacting with Objective-C 'init' methods for potential changes in object lifecycle and reference counting, especially if manual memory management was previously assumed or if objects were unexpectedly deallocated/retained.
• gotcha PyObjC, including `pyobjc-framework-callkit`, is a macOS-specific library. These bindings will only function on macOS operating systems and require the relevant macOS SDK (typically installed via Xcode Command Line Tools).
  Fix: Ensure your development and deployment environment is macOS with Xcode Command Line Tools installed.

Install

• pip install pyobjc-framework-callkit Install CallKit framework bindings

Imports

• *

  from CallKit import *

  Framework imports are case-sensitive and typically match the PascalCase name of the Objective-C framework (e.g., 'CallKit', not 'callkit').
• CXCallController

  from CallKit import CXCallController

  Import specific classes for better clarity and to avoid namespace pollution.

Quickstart

This quickstart demonstrates how to import and instantiate a core CallKit class, `CXCallController`. While the instantiation itself is functional, a complete CallKit integration requires a full macOS application with proper entitlements and event loop management. The commented section shows how you would typically initiate a call action.

import objc
from CallKit import CXCallController

# Instantiate a CallKit controller. 
# This action itself is valid, but for a CXCallController to be fully functional
# and interact with the system, it must be part of a running macOS application
# with appropriate CallKit entitlements.
controller = CXCallController.alloc().init()
print(f"Created CallKit controller instance: {controller}")
print(f"Class name: {controller.__class__.__name__}")

# In a real application, you would use this controller to create and request
# `CXTransaction` objects containing actions like `CXStartCallAction` or `CXEndCallAction`.
# Example of how you might start a call (requires full app context and entitlements):
# import uuid
# from CallKit import CXTransaction, CXStartCallAction, CXHandle
# 
# handle = CXHandle.alloc().initWithType_value_(0, "123-456-7890") # CXHandleTypePhoneNumber = 0
# call_uuid = objc.pyobjc_id(uuid.uuid4())
# start_action = CXStartCallAction.alloc().initWithCallUUID_handle_(call_uuid, handle)
# start_action.setOutgoing_connectionAddress_hasOutgoingProvider_ttyType_(
#     True, None, True, 0 # CXTTYTypeNone = 0
# )
# transaction = CXTransaction.alloc().initWithActions_([start_action])
# # controller.requestTransaction_completion_(transaction, lambda error: ...)