PalmService registerPalmService(const char *name)
{
    Handle public_handle = registerService(name, true);
    Handle private_handle = registerService(name, false);

    return PalmService(std::move(private_handle), std::move(public_handle));
}

bool BatteryTracker::start(IOService* provider)
{
    DEBUG_LOG("BatteryTracker::start: entering start\n");
    
    if (!IOService::start(provider))
    {
        IOLog("BatteryTracker: IOService::start failed!\n");
        return false;
    }
    
    IOWorkLoop* workLoop = getWorkLoop();
    if (!workLoop)
    {
        IOLog("BatteryTracker: getWorkLoop failed\n");
        return false;
    }
    m_pCmdGate = IOCommandGate::commandGate(this);
    if (!m_pCmdGate)
    {
        IOLog("BatteryTracker: IOCommandGate::commmandGate failed\n");
        return false;
    }
    workLoop->addEventSource(m_pCmdGate);
    
	DEBUG_LOG("ACPIBatteryManager: Version 1.52 starting BatteryTracker.\n");
    
    m_pBatteryList = OSArray::withCapacity(2);
    m_pLock = IORecursiveLockAlloc();
    
    registerService();
    
    return true;
}

bool FakeSMC::start(IOService *provider)
{
	if (!super::start(provider)) 
        return false;
    
    OSString *vendor = OSDynamicCast(OSString, getProperty(kFakeSMCFirmwareVendor));
    
    int arg_value = 1;
    
    if (PE_parse_boot_argn("-fakesmc-force-start", &arg_value, sizeof(arg_value))) {
        HWSensorsInfoLog("firmware vendor check disabled");
    }
    else if (vendor && vendor->isEqualTo("Apple")) {
        HWSensorsFatalLog("forbidding start on Apple hardware");
        return false;
    }
    
	if (!smcDevice->initAndStart(provider, this)) {
        HWSensorsInfoLog("failed to initialize SMC device");
		return false;
    }

	registerService();
    
    // Load keys from NVRAM
    if (PE_parse_boot_argn("-fakesmc-use-nvram", &arg_value, sizeof(arg_value))) {
        if (UInt32 count = smcDevice->loadKeysFromNVRAM())
            HWSensorsInfoLog("%d key%s loaded from NVRAM", count, count == 1 ? "" : "s");
        else
            HWSensorsInfoLog("NVRAM will be used to store system written keys...");
    }

	return true;
}

bool
IOI2CLM6x::start	(
						IOService*						provider
					)
{
	IOReturn								status;

	fRegistersAreSaved = false;

	sGetSensorValueSym = OSSymbol::withCString( "getSensorValue" );

	// Start I2CDriver first...
	if ( !( super::start( provider ) ) )
		return( false );

	nrequire( fInitHWFailed, IOI2CLM6x_start_fInitHWFailedErr );

	// Create child nubs.
	require_success( ( status = createChildNubs( fProvider ) ), IOI2CLM6x_start_createChildNubsErr );

	// Register so others can find us with a waitForService().
	registerService();

	return( true );


IOI2CLM6x_start_createChildNubsErr:
IOI2CLM6x_start_fInitHWFailedErr:
	freeI2CResources();
	return( false );
}

Preferences::Preferences()
	: m_currentTimeFormat("HH12")
	, m_showAlertsWhenLocked(true)
	, m_ledThrobberEnabled(true)
	, m_playFeedbackSounds(true)
	, m_sysUiNoHomeButtonMode(true)
	, m_sysUiEnableNextPrevGestures(false)
	, m_lockTimeout(0)
	, m_lsHandle(0)
	, m_imeEnabled(false)
	, m_pinyinEnabled(false)
	, m_pinyinPassthrough(false)
	, m_hwrEnabled(false)
	, m_roamingIndicator("")
	, m_hideWANAlert(false)
	, m_dualRSSI(false)
	, m_airplaneMode(false)
	, m_wifiOn(false)
	, m_bluetoothOn(false)
	, m_show3GForEvdo(false)
	, m_enableVoiceDial(false)
    , m_rotationLock(OrientationEvent::Orientation_Invalid)
	, m_muteOn(false)
	, m_enableALS(true)
{
	init();
	registerService();
}

bool SuperIODevice::start(IOService *provider)
{
	if (!super::start(provider)) return false;

    // Gigabyte mobos usualy use ITE
    if (OSDictionary *matching = serviceMatching(kFakeSMCService)) {
        if (IOService *headingProvider = waitForMatchingService(matching, kFakeSMCDefaultWaitTimeout)) {
            if (OSString *manufacturer = OSDynamicCast(OSString, headingProvider->getProperty(kOEMInfoManufacturer))) {
                if (manufacturer->isEqualTo("Gigabyte")) {
                    if (!detectITEFamilyChip()) {

                        UInt16 ite_id = id;

                        if (!detectWinbondFamilyChip()) {
                            HWSensorsFatalLog("found unsupported chip! ITE sequence ID=0x%x, Winbond sequence ID=0x%x", ite_id, id);
                            return false;
                        }
                    }
                }
            }
        }
        OSSafeRelease(matching);
    }

    // Other vendors usualy use Winbond family chipsets
    if (model == 0) {
        if (!detectWinbondFamilyChip()) {
            
            UInt16 wnbnd_id = id;
            
            if (!detectITEFamilyChip()) {
                HWSensorsFatalLog("found unsupported chip! ITE sequence ID=0x%x, Winbond sequence ID=0x%x", id, wnbnd_id);
                return false;
            }
        }
    }
    
    HWSensorsInfoLog("found %s %s on port=0x%x address=0x%x", vendor, superio_get_model_name(model), port, address);
    
    char string[128];
    
    snprintf(string, sizeof(string), "%s,%s", vendor, superio_get_model_name(model));
    
    setName(string);
    
    //setProperty("name", &string, (UInt32)strlen(string) + 1);
    
    setProperty(kSuperIOHWMAddress, address, 16);
    setProperty(kSuperIOControlPort, port, 8);
    setProperty(kSuperIOModelValue, model, 16);
    
    setProperty(kSuperIOModelName, superio_get_model_name(model));
    setProperty(kSuperIOVendorName, vendor);
    
    setProperty(kSuperIODeviceID, OSData::withBytes(&id, sizeof(id)));
    
    registerService();
    
    return true;
}

void QQmlConfigurableDebugService::init()
{
    Q_D(QQmlConfigurableDebugService);
    QMutexLocker lock(&d->configMutex);
    // If we're not enabled or not blocking, don't wait for configuration
    d->waitingForConfiguration = (registerService() == Enabled && blockingMode());
}

bool IOFireWireAVCLocalNode::start(IOService *provider)
{
	//IOLog( "IOFireWireAVCLocalNode::start\n");

    fDevice = OSDynamicCast(IOFireWireNub, provider);
	if(!fDevice)
        return false;
	
    if (!IOService::start(provider))
        return false;

    fPCRSpace = IOFireWirePCRSpace::getPCRAddressSpace(fDevice->getBus());
    if(!fPCRSpace)
        return false;
    fPCRSpace->activate();

    fAVCTargetSpace = IOFireWireAVCTargetSpace::getAVCTargetSpace(fDevice->getController());
    if(!fAVCTargetSpace)
        return false;
    fAVCTargetSpace->activateWithUserClient((IOFireWireAVCProtocolUserClient*)0xFFFFFFFF);

	// Enable the communication between the PCR space and the Target space objects
	fPCRSpace->setAVCTargetSpacePointer(fAVCTargetSpace);
	
    registerService();

	fStarted = true;
	
    return true;
}

  void Session::loadService(const std::string &moduleName, const std::string& renameModule, const AnyReferenceVector& args)
  {
    size_t separatorPos = moduleName.find_last_of(".");
    std::string package = moduleName.substr(0, separatorPos);
    std::string factory = moduleName.substr(separatorPos + 1);

    std::string rename = renameModule;
    if (rename.empty())
      rename = factory;
    qi::AnyModule p = qi::import(package);

    AnyReferenceVector fullargs;
    SessionPtr thisptr = shared_from_this();
    fullargs.push_back(AnyReference::from(thisptr));
    fullargs.insert(fullargs.end(), args.begin(), args.end());

    int id = p.metaObject().findMethod(factory, fullargs);
    qi::Future<AnyReference> ret;
    if (id > 0)
      ret = p.metaCall(factory, fullargs);
    else
      ret = p.metaCall(factory, args);
    qi::AnyValue retval(ret.value(), false, true);
    registerService(rename, retval.to<qi::AnyObject>());
  }

bool registerService (std::shared_ptr<CommonAPI::Runtime> runtime,
                     Provider *provider,
                      std::string address,
                      std::string friendly,
                      MmError *e) {
        auto factory = runtime->createFactory();
        if (!factory) {
            std::cerr << "Error: Unable to create factory!\n";
            return false;
        }

        auto servicePublisher = runtime->getServicePublisher();
        if (!servicePublisher) {
            std::cerr << "Error: Unable to load service publisher!\n";
            return false;
        }

        if (!e) {
            auto stub = std::make_shared<StubImpl>(provider);

            const bool success= servicePublisher->registerService(stub,
                                                                   address,
                                                                   factory);
            if (!success) {
                std::cerr << "Error: Unable to register " << friendly << " service!\n";
            }
        } else {
            std::cout << "Error connecting to " << friendly << ": " << e->message << std::endl;
            return false;
        }

        return true;
}

bool org_pqrs_driver_Seil::start(IOService* provider) {
    IOLOG_INFO("start\n");

    bool res = super::start(provider);
    if (!res) {
        return res;
    }

    org_pqrs_Seil::GlobalLock::initialize();

    notifier_hookKeyboard_ = addMatchingNotification(gIOMatchedNotification,
                             serviceMatching("IOHIKeyboard"),
                             org_pqrs_driver_Seil::IOHIKeyboard_gIOMatchedNotification_callback,
                             this, nullptr, 0);
    if (notifier_hookKeyboard_ == nullptr) {
        IOLOG_ERROR("initialize_notification notifier_hookKeyboard_ == nullptr\n");
        return false;
    }

    notifier_unhookKeyboard_ = addMatchingNotification(gIOTerminatedNotification,
                               serviceMatching("IOHIKeyboard"),
                               org_pqrs_driver_Seil::IOHIKeyboard_gIOTerminatedNotification_callback,
                               this, nullptr, 0);
    if (notifier_unhookKeyboard_ == nullptr) {
        IOLOG_ERROR("initialize_notification notifier_unhookKeyboard_ == nullptr\n");
        return false;
    }

    // Publish ourselves so clients can find us
    registerService();

    return res;
}

//================================================================================================
//
//   CheckSleepCapability
//
//================================================================================================
//
void
AppleUSBUHCI::CheckSleepCapability(void)
{
    if (_device->getProperty("built-in") && (_ERRATA64BITS & kErrataICH6PowerSequencing)) 
	{
		// The ICH6 UHCI drivers on a Transition system just magically work on sleep/wake
		// so we will just hard code those. Other systems will have to be evaluated later
        setProperty("Card Type","Built-in");
        _controllerCanSleep = true;
    }
    else 
	{
        // This appears to be necessary
		setProperty("Card Type","PCI");
		_controllerCanSleep = false;
    }
	// if we have an ExpressCard attached (non-zero port), then we need to register for some special messages to allow us to override the Resume Enables 
	// for that port (some cards disconnect when the ExpressCard power goes away and we would like to ignore these extra detach events.
	if ((_ExpressCardPort = ExpressCardPort(_device)))
	{
		_device->callPlatformFunction(
									   /* function */ "RegisterDebugDriver",
									   /* waitForFunction */ false,
									   /* provider nubÊ Ê */ _device,
									   /* unused Ê */ (void *) this,
									   /* unused Ê */ (void *) NULL,
									   /* unused Ê */ (void *) NULL );
	}
	_badExpressCardAttached = false;
	
	// Call registerService() so that the IOUSBController object is published and clients (like Prober) can find it
	registerService();
}

bool X3100monitor::start(IOService * provider)
{
	if (!super::start(provider)) 
        return false;
	
	//Find card number
    SInt8 cardIndex = getVacantGPUIndex();
    
    if (cardIndex < 0) {
        HWSensorsWarningLog("failed to obtain vacant GPU index");
        return false;
    }
    
    char key[5];
    
    snprintf(key, 5, KEY_FORMAT_GPU_PROXIMITY_TEMPERATURE, cardIndex);
    
    if (!addSensor(key, TYPE_SP78, 2, kFakeSMCTemperatureSensor, 0)) {
        HWSensorsWarningLog("failed to register temperature sensor");
        return false;
    }
    
    registerService();
	
	return true;	
}

bool TZSensors::start(IOService * provider)
{
	if (!super::start(provider))
        return false;
    
	acpiDevice = (IOACPIPlatformDevice *)provider;
	
	if (!acpiDevice) {
        HWSensorsFatalLog("ACPI device not ready");
        return false;
    }
    
    OSObject *object = NULL;

    if(kIOReturnSuccess == acpiDevice->evaluateObject("_TMP", &object) && object) {
        for (UInt8 i = 0; i < 0xf; i++) {
            char key[5];
            
            snprintf(key, 5, KEY_FORMAT_THERMALZONE_TEMPERATURE, i);
            
            if (!isKeyHandled(key)) {
                if (addSensor(key, TYPE_SP78, TYPE_SPXX_SIZE, kFakeSMCTemperatureSensor, 0)) {
                    break;
                }
            }
        }
    }
    
    registerService();
    
    HWSensorsInfoLog("started on %s", acpiDevice->getName());
    
    return true;
}

C3200VolumeService::C3200VolumeService():
    QtopiaIpcAdaptor("QPE/AudioVolumeManager/C3200VolumeService")
{
    publishAll(Slots);

    QTimer::singleShot(0, this, SLOT(registerService()));
}

void AlarmTransferClient::registerService(const std::string& id)
{
	m_serviceId = id;
	if(m_procname.empty())
		m_procname = m_serviceId;

	registerService();
}

bool ServicePublisher::registerService(std::shared_ptr<_Stub> stub,
                     const std::string& participantId,
                     const std::string& serviceName,
                     const std::string& domain,
                     std::shared_ptr<Factory> factory) {

    std::shared_ptr<StubBase> stubBase = std::dynamic_pointer_cast<StubBase>(stub);
    return registerService(stubBase, _Stub::StubInterface::getInterfaceId(), participantId, serviceName, domain, factory);
}

bool AppleS5L8930XIO::start(IOService* provider) {
    if(!super::start(provider)) {
        panic("failed to start super provider");
    }
    S5L_LOG("Publishing entries to IOService tree plane");
    publishBelow(provider);
    registerService();
    return true;
}

bool WirtualJoy::start(IOService *provider)
{
    if(!super::start(provider))
        return false;

    registerService();
    dmsg("started");
    return true;
}

bool AppleACPIPS2Nub::start(IOService *provider)
{
    if (!super::start(provider)) return false;

    DEBUG_LOG("AppleACPIPS2Nub::start: provider=%p\n", provider);

    /* Initialize our interrupt controller/specifier i-vars */
    m_interruptControllers = OSArray::withCapacity(2);
    m_interruptSpecifiers = OSArray::withCapacity(2);
    if(m_interruptControllers == NULL || m_interruptSpecifiers == NULL)
        return false;

    /* Merge in the keyboard (primary) provider interrupt properties */
    mergeInterruptProperties(provider, LEGACY_KEYBOARD_IRQ);

    /* Initialize and register our power management properties */
	PMinit();
    registerPowerDriver(this, myTwoStates, 2);
    provider->joinPMtree(this);

    /* Find the mouse provider */
    m_mouseProvider = findMouseDevice();
    if(m_mouseProvider != NULL)
    {
        DEBUG_LOG("AppleACPIPS2Nub::start: Found mouse PNP device\n");
        if(attach(m_mouseProvider))
        {
            mergeInterruptProperties(m_mouseProvider, LEGACY_MOUSE_IRQ);
            if(m_mouseProvider->inPlane(gIOPowerPlane))
            {
                m_mouseProvider->joinPMtree(this);
            }
        }
    }

    /* Set our interrupt properties in the IO registry */
    if(m_interruptControllers->getCount() != 0 && m_interruptSpecifiers->getCount() != 0)
    {
        setProperty(gIOInterruptControllersKey, m_interruptControllers);
        setProperty(gIOInterruptSpecifiersKey, m_interruptSpecifiers);
    }

    /* Release the arrays we allocated.  Our properties dictionary has them retained */
    m_interruptControllers->release();
    m_interruptControllers = NULL;
    m_interruptSpecifiers->release();
    m_interruptSpecifiers = NULL;

    /* Make ourselves the ps2controller nub and register so ApplePS2Controller can find us. */
    setName("ps2controller");
    registerService();

    DEBUG_LOG("AppleACPIPS2Nub::start: startup complete\n");

    return true;
}