/* plugin.c generated by valac 0.14.2, the Vala compiler
 * generated from plugin.vala, do not modify */

/*
 * Copyright (C) 2009-2011 Michael 'Mickey' Lauer <mlauer@vanille-media.de>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 */

#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <fsobasics.h>
#include <freesmartphone.h>
#include <fsogsm.h>
#include <fsoframework.h>
#include <gio/gio.h>
#include <fsoresource.h>


#define DBUS_SERVICE_TYPE_DEVICE (dbus_service_device_get_type ())
#define DBUS_SERVICE_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_SERVICE_TYPE_DEVICE, DBusServiceDevice))
#define DBUS_SERVICE_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), DBUS_SERVICE_TYPE_DEVICE, DBusServiceDeviceClass))
#define DBUS_SERVICE_IS_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_SERVICE_TYPE_DEVICE))
#define DBUS_SERVICE_IS_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DBUS_SERVICE_TYPE_DEVICE))
#define DBUS_SERVICE_DEVICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DBUS_SERVICE_TYPE_DEVICE, DBusServiceDeviceClass))

typedef struct _DBusServiceDevice DBusServiceDevice;
typedef struct _DBusServiceDeviceClass DBusServiceDeviceClass;
typedef struct _DBusServiceDevicePrivate DBusServiceDevicePrivate;
#define _g_free0(var) (var = (g_free (var), NULL))
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
typedef struct _dbus_service_device_onModemHangupAsyncData dbus_service_device_onModemHangupAsyncData;
typedef struct _DbusServiceDeviceEnableData DbusServiceDeviceEnableData;
typedef struct _DbusServiceDeviceDisableData DbusServiceDeviceDisableData;
typedef struct _DbusServiceDeviceSuspendData DbusServiceDeviceSuspendData;
typedef struct _DbusServiceDeviceResumeData DbusServiceDeviceResumeData;
#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
typedef struct _DbusServiceDeviceGetInfoData DbusServiceDeviceGetInfoData;
typedef struct _DbusServiceDeviceGetCurrentTimeData DbusServiceDeviceGetCurrentTimeData;
typedef struct _DbusServiceDeviceSetCurrentTimeData DbusServiceDeviceSetCurrentTimeData;
typedef struct _DbusServiceDeviceGetWakeupTimeData DbusServiceDeviceGetWakeupTimeData;
typedef struct _DbusServiceDeviceSetWakeupTimeData DbusServiceDeviceSetWakeupTimeData;
typedef struct _DbusServiceDeviceGetPowerStatusData DbusServiceDeviceGetPowerStatusData;
typedef struct _DbusServiceDeviceGetCapacityData DbusServiceDeviceGetCapacityData;
typedef struct _DbusServiceDeviceDebugCommandData DbusServiceDeviceDebugCommandData;
typedef struct _DbusServiceDeviceDebugInjectResponseData DbusServiceDeviceDebugInjectResponseData;
typedef struct _DbusServiceDeviceDebugPingData DbusServiceDeviceDebugPingData;
typedef struct _DbusServiceDeviceGetFunctionalityData DbusServiceDeviceGetFunctionalityData;
typedef struct _DbusServiceDeviceGetFeaturesData DbusServiceDeviceGetFeaturesData;
typedef struct _DbusServiceDeviceGetMicrophoneMutedData DbusServiceDeviceGetMicrophoneMutedData;
typedef struct _DbusServiceDeviceGetSpeakerVolumeData DbusServiceDeviceGetSpeakerVolumeData;
typedef struct _DbusServiceDeviceSetFunctionalityData DbusServiceDeviceSetFunctionalityData;
typedef struct _DbusServiceDeviceSetMicrophoneMutedData DbusServiceDeviceSetMicrophoneMutedData;
typedef struct _DbusServiceDeviceSetSpeakerVolumeData DbusServiceDeviceSetSpeakerVolumeData;
typedef struct _DbusServiceDeviceGetDeviceStatusData DbusServiceDeviceGetDeviceStatusData;
typedef struct _DbusServiceDeviceChangeAuthCodeData DbusServiceDeviceChangeAuthCodeData;
typedef struct _DbusServiceDeviceDeleteEntryData DbusServiceDeviceDeleteEntryData;
typedef struct _DbusServiceDeviceDeleteMessageData DbusServiceDeviceDeleteMessageData;
typedef struct _DbusServiceDeviceGetAuthCodeRequiredData DbusServiceDeviceGetAuthCodeRequiredData;
typedef struct _DbusServiceDeviceGetAuthStatusData DbusServiceDeviceGetAuthStatusData;
typedef struct _DbusServiceDeviceGetHomeZoneParametersData DbusServiceDeviceGetHomeZoneParametersData;
typedef struct _DbusServiceDeviceGetPhonebookInfoData DbusServiceDeviceGetPhonebookInfoData;
typedef struct _DbusServiceDeviceGetServiceCenterNumberData DbusServiceDeviceGetServiceCenterNumberData;
typedef struct _DbusServiceDeviceGetSimInfoData DbusServiceDeviceGetSimInfoData;
typedef struct _DbusServiceDeviceGetUnlockCountersData DbusServiceDeviceGetUnlockCountersData;
typedef struct _DbusServiceDeviceRetrieveMessageData DbusServiceDeviceRetrieveMessageData;
typedef struct _DbusServiceDeviceRetrievePhonebookData DbusServiceDeviceRetrievePhonebookData;
typedef struct _DbusServiceDeviceSendAuthCodeData DbusServiceDeviceSendAuthCodeData;
typedef struct _DbusServiceDeviceSendGenericSimCommandData DbusServiceDeviceSendGenericSimCommandData;
typedef struct _DbusServiceDeviceSendRestrictedSimCommandData DbusServiceDeviceSendRestrictedSimCommandData;
typedef struct _DbusServiceDeviceSendStoredMessageData DbusServiceDeviceSendStoredMessageData;
typedef struct _DbusServiceDeviceSetAuthCodeRequiredData DbusServiceDeviceSetAuthCodeRequiredData;
typedef struct _DbusServiceDeviceSetServiceCenterNumberData DbusServiceDeviceSetServiceCenterNumberData;
typedef struct _DbusServiceDeviceStoreEntryData DbusServiceDeviceStoreEntryData;
typedef struct _DbusServiceDeviceStoreMessageData DbusServiceDeviceStoreMessageData;
typedef struct _DbusServiceDeviceUnlockData DbusServiceDeviceUnlockData;
typedef struct _DbusServiceDeviceGetSizeForTextMessageData DbusServiceDeviceGetSizeForTextMessageData;
typedef struct _DbusServiceDeviceRetrieveTextMessagesData DbusServiceDeviceRetrieveTextMessagesData;
typedef struct _DbusServiceDeviceSendTextMessageData DbusServiceDeviceSendTextMessageData;
typedef struct _DbusServiceDeviceDisableCallForwardingData DbusServiceDeviceDisableCallForwardingData;
typedef struct _DbusServiceDeviceEnableCallForwardingData DbusServiceDeviceEnableCallForwardingData;
typedef struct _DbusServiceDeviceGetCallForwardingData DbusServiceDeviceGetCallForwardingData;
typedef struct _DbusServiceDeviceGetCallingIdentificationData DbusServiceDeviceGetCallingIdentificationData;
#define _fso_gsm_network_time_report_unref0(var) ((var == NULL) ? NULL : (var = (fso_gsm_network_time_report_unref (var), NULL)))
typedef struct _DbusServiceDeviceGetTimeReportData DbusServiceDeviceGetTimeReportData;
typedef struct _DbusServiceDeviceGetSignalStrengthData DbusServiceDeviceGetSignalStrengthData;
typedef struct _DbusServiceDeviceGetStatusData DbusServiceDeviceGetStatusData;
typedef struct _DbusServiceDeviceListProvidersData DbusServiceDeviceListProvidersData;
typedef struct _DbusServiceDeviceRegisterData DbusServiceDeviceRegisterData;
typedef struct _DbusServiceDeviceRegisterWithProviderData DbusServiceDeviceRegisterWithProviderData;
typedef struct _DbusServiceDeviceSendUssdRequestData DbusServiceDeviceSendUssdRequestData;
typedef struct _DbusServiceDeviceSetCallingIdentificationData DbusServiceDeviceSetCallingIdentificationData;
typedef struct _DbusServiceDeviceUnregisterData DbusServiceDeviceUnregisterData;
typedef struct _DbusServiceDeviceActivateData DbusServiceDeviceActivateData;
typedef struct _DbusServiceDeviceActivateConferenceData DbusServiceDeviceActivateConferenceData;
typedef struct _DbusServiceDeviceEmergencyData DbusServiceDeviceEmergencyData;
typedef struct _DbusServiceDeviceHoldActiveData DbusServiceDeviceHoldActiveData;
typedef struct _DbusServiceDeviceInitiateData DbusServiceDeviceInitiateData;
typedef struct _DbusServiceDeviceJoinData DbusServiceDeviceJoinData;
typedef struct _DbusServiceDeviceListCallsData DbusServiceDeviceListCallsData;
typedef struct _DbusServiceDeviceReleaseData DbusServiceDeviceReleaseData;
typedef struct _DbusServiceDeviceReleaseAllData DbusServiceDeviceReleaseAllData;
typedef struct _DbusServiceDeviceReleaseHeldData DbusServiceDeviceReleaseHeldData;
typedef struct _DbusServiceDeviceSendDtmfData DbusServiceDeviceSendDtmfData;
typedef struct _DbusServiceDeviceTransferData DbusServiceDeviceTransferData;
typedef struct _DbusServiceDeviceActivateContextData DbusServiceDeviceActivateContextData;
typedef struct _DbusServiceDeviceDeactivateContextData DbusServiceDeviceDeactivateContextData;
typedef struct _DbusServiceDeviceGetContextStatusData DbusServiceDeviceGetContextStatusData;
typedef struct _DbusServiceDeviceGetCredentialsData DbusServiceDeviceGetCredentialsData;
typedef struct _DbusServiceDeviceGetRoamingAllowedData DbusServiceDeviceGetRoamingAllowedData;
typedef struct _DbusServiceDeviceSetRoamingAllowedData DbusServiceDeviceSetRoamingAllowedData;
typedef struct _DbusServiceDeviceInternalStatusUpdateData DbusServiceDeviceInternalStatusUpdateData;
typedef struct _DbusServiceDeviceSetCredentialsData DbusServiceDeviceSetCredentialsData;
typedef struct _DbusServiceDeviceGetCellBroadcastSubscriptionsData DbusServiceDeviceGetCellBroadcastSubscriptionsData;
typedef struct _DbusServiceDeviceSetCellBroadcastSubscriptionsData DbusServiceDeviceSetCellBroadcastSubscriptionsData;
typedef struct _DbusServiceDeviceGetHomeZoneStatusData DbusServiceDeviceGetHomeZoneStatusData;
typedef struct _DbusServiceDeviceGetKnownHomeZonesData DbusServiceDeviceGetKnownHomeZonesData;
typedef struct _DbusServiceDeviceGetServingCellInformationData DbusServiceDeviceGetServingCellInformationData;
typedef struct _DbusServiceDeviceGetNeighbourCellInformationData DbusServiceDeviceGetNeighbourCellInformationData;
typedef struct _DbusServiceDeviceGetVoiceMailboxNumberData DbusServiceDeviceGetVoiceMailboxNumberData;
typedef struct _DbusServiceDeviceSetVoiceMailboxNumberData DbusServiceDeviceSetVoiceMailboxNumberData;
typedef struct _DbusServiceDeviceGetStoredVoiceMailsData DbusServiceDeviceGetStoredVoiceMailsData;

#define DBUS_SERVICE_TYPE_RESOURCE (dbus_service_resource_get_type ())
#define DBUS_SERVICE_RESOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_SERVICE_TYPE_RESOURCE, DBusServiceResource))
#define DBUS_SERVICE_RESOURCE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), DBUS_SERVICE_TYPE_RESOURCE, DBusServiceResourceClass))
#define DBUS_SERVICE_IS_RESOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_SERVICE_TYPE_RESOURCE))
#define DBUS_SERVICE_IS_RESOURCE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DBUS_SERVICE_TYPE_RESOURCE))
#define DBUS_SERVICE_RESOURCE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DBUS_SERVICE_TYPE_RESOURCE, DBusServiceResourceClass))

typedef struct _DBusServiceResource DBusServiceResource;
typedef struct _DBusServiceResourceClass DBusServiceResourceClass;
typedef struct _DBusServiceResourcePrivate DBusServiceResourcePrivate;
typedef struct _dbus_service_resource_enableResourceData dbus_service_resource_enableResourceData;
typedef struct _dbus_service_resource_disableResourceData dbus_service_resource_disableResourceData;
typedef struct _dbus_service_resource_suspendResourceData dbus_service_resource_suspendResourceData;
typedef struct _dbus_service_resource_resumeResourceData dbus_service_resource_resumeResourceData;
typedef struct _DbusServiceResourceDependenciesData DbusServiceResourceDependenciesData;
typedef struct _AsyncHelperData AsyncHelperData;

struct _DBusServiceDevice {
	FsoFrameworkAbstractObject parent_instance;
	DBusServiceDevicePrivate * priv;
};

struct _DBusServiceDeviceClass {
	FsoFrameworkAbstractObjectClass parent_class;
};

struct _dbus_service_device_onModemHangupAsyncData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gboolean _tmp0_;
	gboolean ok;
	gboolean _tmp1_;
};

struct _DbusServiceDeviceEnableData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gboolean result;
	FsoGsmModem* _tmp0_;
	gboolean _tmp1_;
	gboolean ok;
	gboolean _tmp2_;
	FsoFrameworkLogger* _tmp3_;
	FsoFrameworkLogger* _tmp4_;
};

struct _DbusServiceDeviceDisableData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FsoGsmModem* _tmp0_;
	FsoFrameworkLogger* _tmp1_;
};

struct _DbusServiceDeviceSuspendData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FsoGsmModem* _tmp0_;
	gboolean _tmp1_;
	gboolean ok;
	gboolean _tmp2_;
	FsoFrameworkLogger* _tmp3_;
	FsoFrameworkLogger* _tmp4_;
};

struct _DbusServiceDeviceResumeData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FsoGsmModem* _tmp0_;
	gboolean _tmp1_;
	gboolean ok;
	gboolean _tmp2_;
	FsoFrameworkLogger* _tmp3_;
	FsoFrameworkLogger* _tmp4_;
};

struct _DbusServiceDeviceGetInfoData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	GHashTable* result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDeviceGetInformation* m;
	FsoGsmDeviceGetInformation* _tmp2_;
	GError* e;
	GError* _tmp3_;
	const gchar* _tmp4_;
	GError* _tmp5_;
	FsoGsmDeviceGetInformation* _tmp6_;
	GHashTable* _tmp7_;
	GHashTable* _tmp8_;
	GHashTable* _tmp9_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetCurrentTimeData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDeviceGetCurrentTime* m;
	FsoGsmDeviceGetCurrentTime* _tmp2_;
	GError* e;
	GError* _tmp3_;
	const gchar* _tmp4_;
	GError* _tmp5_;
	FsoGsmDeviceGetCurrentTime* _tmp6_;
	gint _tmp7_;
	gint _tmp8_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSetCurrentTimeData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint seconds_since_epoch;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDeviceSetCurrentTime* m;
	FsoGsmDeviceSetCurrentTime* _tmp2_;
	gint _tmp3_;
	GError* e;
	GError* _tmp4_;
	const gchar* _tmp5_;
	GError* _tmp6_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetWakeupTimeData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDeviceGetAlarmTime* m;
	FsoGsmDeviceGetAlarmTime* _tmp2_;
	GError* e;
	GError* _tmp3_;
	const gchar* _tmp4_;
	GError* _tmp5_;
	FsoGsmDeviceGetAlarmTime* _tmp6_;
	gint _tmp7_;
	gint _tmp8_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSetWakeupTimeData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint seconds_since_epoch;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDeviceSetAlarmTime* m;
	FsoGsmDeviceSetAlarmTime* _tmp2_;
	gint _tmp3_;
	GError* e;
	GError* _tmp4_;
	const gchar* _tmp5_;
	GError* _tmp6_;
	gint _tmp7_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetPowerStatusData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FreeSmartphoneDevicePowerStatus result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDeviceGetPowerStatus* m;
	FsoGsmDeviceGetPowerStatus* _tmp2_;
	FsoGsmDeviceGetPowerStatus* _tmp3_;
	FreeSmartphoneDevicePowerStatus _tmp4_;
	FreeSmartphoneDevicePowerStatus _tmp5_;
	GError* e;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetCapacityData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDeviceGetPowerStatus* m;
	FsoGsmDeviceGetPowerStatus* _tmp2_;
	FsoGsmDeviceGetPowerStatus* _tmp3_;
	gint _tmp4_;
	gint _tmp5_;
	GError* e;
	GError * _inner_error_;
};

struct _DbusServiceDeviceDebugCommandData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* command;
	gchar* channel;
	gchar* result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDebugCommand* m;
	FsoGsmDebugCommand* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	FsoGsmDebugCommand* _tmp5_;
	const gchar* _tmp6_;
	const gchar* _tmp7_;
	gchar* _tmp8_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceDebugInjectResponseData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* response;
	gchar* channel;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDebugInjectResponse* m;
	FsoGsmDebugInjectResponse* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceDebugPingData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDebugPing* m;
	FsoGsmDebugPing* _tmp2_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetFunctionalityData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* level;
	gboolean autoregister;
	gchar* pin;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDeviceGetFunctionality* m;
	FsoGsmDeviceGetFunctionality* _tmp2_;
	FsoGsmDeviceGetFunctionality* _tmp3_;
	const gchar* _tmp4_;
	const gchar* _tmp5_;
	gchar* _tmp6_;
	FsoGsmDeviceGetFunctionality* _tmp7_;
	gboolean _tmp8_;
	gboolean _tmp9_;
	FsoGsmDeviceGetFunctionality* _tmp10_;
	const gchar* _tmp11_;
	const gchar* _tmp12_;
	gchar* _tmp13_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetFeaturesData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	GHashTable* result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDeviceGetFeatures* m;
	FsoGsmDeviceGetFeatures* _tmp2_;
	FsoGsmDeviceGetFeatures* _tmp3_;
	GHashTable* _tmp4_;
	GHashTable* _tmp5_;
	GHashTable* _tmp6_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetMicrophoneMutedData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gboolean result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDeviceGetMicrophoneMuted* m;
	FsoGsmDeviceGetMicrophoneMuted* _tmp2_;
	FsoGsmDeviceGetMicrophoneMuted* _tmp3_;
	gboolean _tmp4_;
	gboolean _tmp5_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetSpeakerVolumeData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDeviceGetSpeakerVolume* m;
	FsoGsmDeviceGetSpeakerVolume* _tmp2_;
	FsoGsmDeviceGetSpeakerVolume* _tmp3_;
	gint _tmp4_;
	gint _tmp5_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSetFunctionalityData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* level;
	gboolean autoregister;
	gchar* pin;
	FsoGsmModem* _tmp0_;
	const gchar* _tmp1_;
	gboolean _tmp2_;
	const gchar* _tmp3_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSetMicrophoneMutedData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gboolean muted;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDeviceSetMicrophoneMuted* m;
	FsoGsmDeviceSetMicrophoneMuted* _tmp2_;
	gboolean _tmp3_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSetSpeakerVolumeData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint volume;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmDeviceSetSpeakerVolume* m;
	FsoGsmDeviceSetSpeakerVolume* _tmp2_;
	gint _tmp3_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetDeviceStatusData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FreeSmartphoneGSMDeviceStatus result;
	FsoGsmModem* _tmp0_;
	FreeSmartphoneGSMDeviceStatus _tmp1_;
};

struct _DbusServiceDeviceChangeAuthCodeData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* old_pin;
	gchar* new_pin;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimChangeAuthCode* m;
	FsoGsmSimChangeAuthCode* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceDeleteEntryData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* category;
	gint index;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimDeleteEntry* m;
	FsoGsmSimDeleteEntry* _tmp2_;
	const gchar* _tmp3_;
	gint _tmp4_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceDeleteMessageData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint index;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimDeleteMessage* m;
	FsoGsmSimDeleteMessage* _tmp2_;
	gint _tmp3_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetAuthCodeRequiredData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gboolean result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimGetAuthCodeRequired* m;
	FsoGsmSimGetAuthCodeRequired* _tmp2_;
	FsoGsmSimGetAuthCodeRequired* _tmp3_;
	gboolean _tmp4_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetAuthStatusData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FreeSmartphoneGSMSIMAuthStatus result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimGetAuthStatus* m;
	FsoGsmSimGetAuthStatus* _tmp2_;
	FsoGsmSimGetAuthStatus* _tmp3_;
	FreeSmartphoneGSMSIMAuthStatus _tmp4_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetHomeZoneParametersData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FreeSmartphoneGSMSIMHomeZone* result;
	gint result_length1;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetPhonebookInfoData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* category;
	gint slots;
	gint numberlength;
	gint namelength;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimGetPhonebookInfo* m;
	FsoGsmSimGetPhonebookInfo* _tmp2_;
	const gchar* _tmp3_;
	gint _tmp4_;
	gint _tmp5_;
	gint _tmp6_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetServiceCenterNumberData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimGetServiceCenterNumber* m;
	FsoGsmSimGetServiceCenterNumber* _tmp2_;
	FsoGsmSimGetServiceCenterNumber* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetSimInfoData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	GHashTable* result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimGetInformation* m;
	FsoGsmSimGetInformation* _tmp2_;
	FsoGsmSimGetInformation* _tmp3_;
	GHashTable* _tmp4_;
	GHashTable* _tmp5_;
	GHashTable* _tmp6_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetUnlockCountersData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	GHashTable* result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimGetUnlockCounters* m;
	FsoGsmSimGetUnlockCounters* _tmp2_;
	FsoGsmSimGetUnlockCounters* _tmp3_;
	GHashTable* _tmp4_;
	GHashTable* _tmp5_;
	GHashTable* _tmp6_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceRetrieveMessageData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint index;
	gchar* status;
	gchar* number;
	gchar* contents;
	GHashTable* properties;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimRetrieveMessage* m;
	FsoGsmSimRetrieveMessage* _tmp2_;
	gint _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	GHashTable* _tmp7_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceRetrievePhonebookData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* category;
	gint mindex;
	gint maxdex;
	FreeSmartphoneGSMSIMEntry* result;
	gint result_length1;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimRetrievePhonebook* m;
	FsoGsmSimRetrievePhonebook* _tmp2_;
	const gchar* _tmp3_;
	gint _tmp4_;
	gint _tmp5_;
	FsoGsmSimRetrievePhonebook* _tmp6_;
	FreeSmartphoneGSMSIMEntry* _tmp7_;
	gint _tmp7__length1;
	FreeSmartphoneGSMSIMEntry* _tmp8_;
	gint _tmp8__length1;
	FreeSmartphoneGSMSIMEntry* _tmp9_;
	gint _tmp9__length1;
	FreeSmartphoneGSMSIMEntry* _tmp10_;
	gint _tmp10__length1;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSendAuthCodeData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* pin;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimSendAuthCode* m;
	FsoGsmSimSendAuthCode* _tmp2_;
	const gchar* _tmp3_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSendGenericSimCommandData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* command;
	gchar* result;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSendRestrictedSimCommandData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint command;
	gint fileid;
	gint p1;
	gint p2;
	gint p3;
	gchar* data;
	gchar* result;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSendStoredMessageData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint index;
	gint transaction_index;
	gchar* timestamp;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimSendStoredMessage* m;
	FsoGsmSimSendStoredMessage* _tmp2_;
	gint _tmp3_;
	FsoGsmSimSendStoredMessage* _tmp4_;
	gint _tmp5_;
	gint _tmp6_;
	FsoGsmSimSendStoredMessage* _tmp7_;
	const gchar* _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSetAuthCodeRequiredData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gboolean check;
	gchar* pin;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimSetAuthCodeRequired* m;
	FsoGsmSimSetAuthCodeRequired* _tmp2_;
	gboolean _tmp3_;
	const gchar* _tmp4_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSetServiceCenterNumberData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* number;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimSetServiceCenterNumber* m;
	FsoGsmSimSetServiceCenterNumber* _tmp2_;
	const gchar* _tmp3_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceStoreEntryData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* category;
	gint index;
	gchar* name;
	gchar* number;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimWriteEntry* m;
	FsoGsmSimWriteEntry* _tmp2_;
	const gchar* _tmp3_;
	gint _tmp4_;
	const gchar* _tmp5_;
	const gchar* _tmp6_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceStoreMessageData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* recipient_number;
	gchar* contents;
	GHashTable* properties;
	gint result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimStoreMessage* m;
	FsoGsmSimStoreMessage* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	FsoGsmSimStoreMessage* _tmp5_;
	gint _tmp6_;
	gint _tmp7_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceUnlockData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* puk;
	gchar* new_pin;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSimUnlock* m;
	FsoGsmSimUnlock* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetSizeForTextMessageData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* contents;
	guint result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSmsGetSizeForTextMessage* m;
	FsoGsmSmsGetSizeForTextMessage* _tmp2_;
	const gchar* _tmp3_;
	FsoGsmSmsGetSizeForTextMessage* _tmp4_;
	guint _tmp5_;
	guint _tmp6_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceRetrieveTextMessagesData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FreeSmartphoneGSMSIMMessage* result;
	gint result_length1;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSmsRetrieveTextMessages* m;
	FsoGsmSmsRetrieveTextMessages* _tmp2_;
	FsoGsmSmsRetrieveTextMessages* _tmp3_;
	FreeSmartphoneGSMSIMMessage* _tmp4_;
	gint _tmp4__length1;
	FreeSmartphoneGSMSIMMessage* _tmp5_;
	gint _tmp5__length1;
	FreeSmartphoneGSMSIMMessage* _tmp6_;
	gint _tmp6__length1;
	FreeSmartphoneGSMSIMMessage* _tmp7_;
	gint _tmp7__length1;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSendTextMessageData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* recipient_number;
	gchar* contents;
	gboolean want_report;
	gint transaction_index;
	gchar* timestamp;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmSmsSendTextMessage* m;
	FsoGsmSmsSendTextMessage* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	gboolean _tmp5_;
	FsoGsmSmsSendTextMessage* _tmp6_;
	gint _tmp7_;
	gint _tmp8_;
	FsoGsmSmsSendTextMessage* _tmp9_;
	const gchar* _tmp10_;
	const gchar* _tmp11_;
	gchar* _tmp12_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceDisableCallForwardingData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* reason;
	gchar* class_;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceEnableCallForwardingData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* reason;
	gchar* class_;
	gchar* number;
	gint timeout;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetCallForwardingData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* reason;
	GHashTable* result;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetCallingIdentificationData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FreeSmartphoneGSMCallingIdentificationStatus result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmNetworkGetCallingId* m;
	FsoGsmNetworkGetCallingId* _tmp2_;
	FsoGsmNetworkGetCallingId* _tmp3_;
	FreeSmartphoneGSMCallingIdentificationStatus _tmp4_;
	FreeSmartphoneGSMCallingIdentificationStatus _tmp5_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetTimeReportData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint time;
	gint timestamp;
	gint zone;
	gint zonestamp;
	FsoGsmModem* _tmp0_;
	FsoGsmModemData* _tmp1_;
	FsoGsmModemData* _tmp2_;
	FsoGsmNetworkTimeReport* _tmp3_;
	FsoGsmNetworkTimeReport* _tmp4_;
	FsoGsmNetworkTimeReport* _tmp5_;
	FsoGsmNetworkTimeReport* ltr;
	FsoGsmNetworkTimeReport* _tmp6_;
	gint _tmp7_;
	FsoGsmNetworkTimeReport* _tmp8_;
	gint _tmp9_;
	FsoGsmNetworkTimeReport* _tmp10_;
	gint _tmp11_;
	FsoGsmNetworkTimeReport* _tmp12_;
	gint _tmp13_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetSignalStrengthData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmNetworkGetSignalStrength* m;
	FsoGsmNetworkGetSignalStrength* _tmp2_;
	FsoGsmNetworkGetSignalStrength* _tmp3_;
	gint _tmp4_;
	gint _tmp5_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetStatusData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	GHashTable* result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmNetworkGetStatus* m;
	FsoGsmNetworkGetStatus* _tmp2_;
	FsoGsmNetworkGetStatus* _tmp3_;
	GHashTable* _tmp4_;
	GHashTable* _tmp5_;
	GHashTable* _tmp6_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceListProvidersData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FreeSmartphoneGSMNetworkProvider* result;
	gint result_length1;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmNetworkListProviders* m;
	FsoGsmNetworkListProviders* _tmp2_;
	FsoGsmNetworkListProviders* _tmp3_;
	FreeSmartphoneGSMNetworkProvider* _tmp4_;
	gint _tmp4__length1;
	FreeSmartphoneGSMNetworkProvider* _tmp5_;
	gint _tmp5__length1;
	FreeSmartphoneGSMNetworkProvider* _tmp6_;
	gint _tmp6__length1;
	FreeSmartphoneGSMNetworkProvider* _tmp7_;
	gint _tmp7__length1;
	GError * _inner_error_;
};

struct _DbusServiceDeviceRegisterData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmNetworkRegister* m;
	FsoGsmNetworkRegister* _tmp2_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceRegisterWithProviderData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* operator_code;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmNetworkRegisterWithProvider* m;
	FsoGsmNetworkRegisterWithProvider* _tmp2_;
	const gchar* _tmp3_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSendUssdRequestData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* request;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmNetworkSendUssdRequest* m;
	FsoGsmNetworkSendUssdRequest* _tmp2_;
	const gchar* _tmp3_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSetCallingIdentificationData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FreeSmartphoneGSMCallingIdentificationStatus status;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmNetworkSetCallingId* m;
	FsoGsmNetworkSetCallingId* _tmp2_;
	FreeSmartphoneGSMCallingIdentificationStatus _tmp3_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceUnregisterData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmNetworkUnregister* m;
	FsoGsmNetworkUnregister* _tmp2_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceActivateData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint id;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmCallActivate* m;
	FsoGsmCallActivate* _tmp2_;
	gint _tmp3_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceActivateConferenceData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint id;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceEmergencyData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* number;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceHoldActiveData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmCallHoldActive* m;
	FsoGsmCallHoldActive* _tmp2_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceInitiateData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* number;
	gchar* ctype;
	gint result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmCallInitiate* m;
	FsoGsmCallInitiate* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	FsoGsmCallInitiate* _tmp5_;
	gint _tmp6_;
	gint _tmp7_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceJoinData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceListCallsData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FreeSmartphoneGSMCallDetail* result;
	gint result_length1;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmCallListCalls* m;
	FsoGsmCallListCalls* _tmp2_;
	FsoGsmCallListCalls* _tmp3_;
	FreeSmartphoneGSMCallDetail* _tmp4_;
	gint _tmp4__length1;
	FreeSmartphoneGSMCallDetail* _tmp5_;
	gint _tmp5__length1;
	FreeSmartphoneGSMCallDetail* _tmp6_;
	gint _tmp6__length1;
	FreeSmartphoneGSMCallDetail* _tmp7_;
	gint _tmp7__length1;
	GError * _inner_error_;
};

struct _DbusServiceDeviceReleaseData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gint id;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmCallRelease* m;
	FsoGsmCallRelease* _tmp2_;
	gint _tmp3_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceReleaseAllData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmCallReleaseAll* m;
	FsoGsmCallReleaseAll* _tmp2_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceReleaseHeldData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSendDtmfData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* tones;
	const gchar* _tmp0_;
	FsoGsmModem* _tmp1_;
	gpointer _tmp2_;
	FsoGsmCallSendDtmf* m;
	FsoGsmCallSendDtmf* _tmp3_;
	const gchar* _tmp4_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceTransferData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* number;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceActivateContextData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmPdpActivateContext* m;
	FsoGsmPdpActivateContext* _tmp2_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceDeactivateContextData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmPdpDeactivateContext* m;
	FsoGsmPdpDeactivateContext* _tmp2_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetContextStatusData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	FreeSmartphoneGSMContextStatus status;
	GHashTable* properties;
	FsoGsmModem* _tmp0_;
	FsoGsmIPdpHandler* _tmp1_;
	FsoGsmIPdpHandler* _tmp2_;
	FreeSmartphoneGSMContextStatus _tmp3_;
	FreeSmartphoneGSMContextStatus _tmp4_;
	FsoGsmModem* _tmp5_;
	FsoGsmIPdpHandler* _tmp6_;
	FsoGsmIPdpHandler* _tmp7_;
	GHashTable* _tmp8_;
	GHashTable* _tmp9_;
	GHashTable* _tmp10_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetCredentialsData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* apn;
	gchar* username;
	gchar* password;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmPdpGetCredentials* m;
	FsoGsmPdpGetCredentials* _tmp2_;
	FsoGsmPdpGetCredentials* _tmp3_;
	const gchar* _tmp4_;
	const gchar* _tmp5_;
	gchar* _tmp6_;
	FsoGsmPdpGetCredentials* _tmp7_;
	const gchar* _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	FsoGsmPdpGetCredentials* _tmp11_;
	const gchar* _tmp12_;
	const gchar* _tmp13_;
	gchar* _tmp14_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetRoamingAllowedData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gboolean result;
	FsoGsmModem* _tmp0_;
	FsoGsmModemData* _tmp1_;
	FsoGsmModemData* _tmp2_;
	gboolean _tmp3_;
	gboolean _tmp4_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSetRoamingAllowedData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gboolean state;
	FsoGsmModem* _tmp0_;
	FsoGsmModemData* _tmp1_;
	FsoGsmModemData* _tmp2_;
	gboolean _tmp3_;
	FsoGsmModem* _tmp4_;
	FsoGsmIPdpHandler* _tmp5_;
	FsoGsmIPdpHandler* _tmp6_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceInternalStatusUpdateData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* status;
	GHashTable* properties;
	FsoGsmModem* _tmp0_;
	FsoGsmIPdpHandler* _tmp1_;
	FsoGsmIPdpHandler* _tmp2_;
	const gchar* _tmp3_;
	GHashTable* _tmp4_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSetCredentialsData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* apn;
	gchar* username;
	gchar* password;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmPdpSetCredentials* m;
	FsoGsmPdpSetCredentials* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	const gchar* _tmp5_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetCellBroadcastSubscriptionsData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmCbGetCellBroadcastSubscriptions* m;
	FsoGsmCbGetCellBroadcastSubscriptions* _tmp2_;
	FsoGsmCbGetCellBroadcastSubscriptions* _tmp3_;
	const gchar* _tmp4_;
	const gchar* _tmp5_;
	gchar* _tmp6_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSetCellBroadcastSubscriptionsData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* subscriptions;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmCbSetCellBroadcastSubscriptions* m;
	FsoGsmCbSetCellBroadcastSubscriptions* _tmp2_;
	const gchar* _tmp3_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetHomeZoneStatusData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* result;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetKnownHomeZonesData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar** result;
	gint result_length1;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetServingCellInformationData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	GHashTable* result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmMonitorGetServingCellInformation* m;
	FsoGsmMonitorGetServingCellInformation* _tmp2_;
	FsoGsmMonitorGetServingCellInformation* _tmp3_;
	GHashTable* _tmp4_;
	GHashTable* _tmp5_;
	GHashTable* _tmp6_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetNeighbourCellInformationData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	GHashTable** result;
	gint result_length1;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmMonitorGetNeighbourCellInformation* m;
	FsoGsmMonitorGetNeighbourCellInformation* _tmp2_;
	FsoGsmMonitorGetNeighbourCellInformation* _tmp3_;
	GHashTable** _tmp4_;
	gint _tmp4__length1;
	GHashTable** _tmp5_;
	gint _tmp5__length1;
	GHashTable** _tmp6_;
	gint _tmp6__length1;
	GHashTable** _tmp7_;
	gint _tmp7__length1;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetVoiceMailboxNumberData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* result;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmVoiceMailboxGetNumber* m;
	FsoGsmVoiceMailboxGetNumber* _tmp2_;
	FsoGsmVoiceMailboxGetNumber* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceSetVoiceMailboxNumberData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar* number;
	FsoGsmModem* _tmp0_;
	gpointer _tmp1_;
	FsoGsmVoiceMailboxSetNumber* m;
	FsoGsmVoiceMailboxSetNumber* _tmp2_;
	const gchar* _tmp3_;
	GError * _inner_error_;
};

struct _DbusServiceDeviceGetStoredVoiceMailsData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceDevice* self;
	gchar** result;
	gint result_length1;
	GError* _tmp0_;
	GError * _inner_error_;
};

struct _DBusServiceResource {
	FsoFrameworkAbstractDBusResource parent_instance;
	DBusServiceResourcePrivate * priv;
};

struct _DBusServiceResourceClass {
	FsoFrameworkAbstractDBusResourceClass parent_class;
};

struct _dbus_service_resource_enableResourceData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceResource* self;
	FsoFrameworkLogger* _tmp0_;
	DBusServiceDevice* _tmp1_;
	gboolean _tmp2_;
	gboolean ok;
	gboolean _tmp3_;
	GError* _tmp4_;
	GError * _inner_error_;
};

struct _dbus_service_resource_disableResourceData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceResource* self;
	FsoFrameworkLogger* _tmp0_;
	DBusServiceDevice* _tmp1_;
};

struct _dbus_service_resource_suspendResourceData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceResource* self;
	FsoFrameworkLogger* _tmp0_;
	DBusServiceDevice* _tmp1_;
};

struct _dbus_service_resource_resumeResourceData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceResource* self;
	FsoFrameworkLogger* _tmp0_;
	DBusServiceDevice* _tmp1_;
};

struct _DbusServiceResourceDependenciesData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceResource* self;
	GHashTable* result;
	GHashFunc _tmp0_;
	GEqualFunc _tmp1_;
	GHashTable* _tmp2_;
	GHashTable* dependencies;
	gchar* _tmp3_;
	gchar* services;
	gboolean first;
	GList* _tmp4_;
	GList* service_collection;
	GList* service_it;
	gchar* _tmp5_;
	gchar* service;
	gboolean _tmp6_;
	const gchar* _tmp7_;
	gchar* _tmp8_;
	const gchar* _tmp9_;
	const gchar* _tmp10_;
	gchar* _tmp11_;
	GHashTable* _tmp12_;
	gchar* _tmp13_;
	const gchar* _tmp14_;
	GVariant* _tmp15_;
};

struct _AsyncHelperData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	DBusServiceResource* _tmp0_;
};


static gpointer dbus_service_device_parent_class = NULL;
static FsoGsmModem* dbus_service_device_modem;
static FsoGsmModem* dbus_service_device_modem = NULL;
extern GType dbus_service_device_modemclass;
GType dbus_service_device_modemclass = 0UL;
static FreeSmartphoneInfoIface* dbus_service_device_free_smartphone_info_parent_iface = NULL;
static FreeSmartphoneDeviceRealtimeClockIface* dbus_service_device_free_smartphone_device_realtime_clock_parent_iface = NULL;
static FreeSmartphoneDevicePowerSupplyIface* dbus_service_device_free_smartphone_device_power_supply_parent_iface = NULL;
static FreeSmartphoneGSMDebugIface* dbus_service_device_free_smartphone_gsm_debug_parent_iface = NULL;
static FreeSmartphoneGSMDeviceIface* dbus_service_device_free_smartphone_gsm_device_parent_iface = NULL;
static FreeSmartphoneGSMSIMIface* dbus_service_device_free_smartphone_gsm_sim_parent_iface = NULL;
static FreeSmartphoneGSMSMSIface* dbus_service_device_free_smartphone_gsm_sms_parent_iface = NULL;
static FreeSmartphoneGSMNetworkIface* dbus_service_device_free_smartphone_gsm_network_parent_iface = NULL;
static FreeSmartphoneGSMCallIface* dbus_service_device_free_smartphone_gsm_call_parent_iface = NULL;
static FreeSmartphoneGSMPDPIface* dbus_service_device_free_smartphone_gsm_pdp_parent_iface = NULL;
static FreeSmartphoneGSMCBIface* dbus_service_device_free_smartphone_gsm_cb_parent_iface = NULL;
static FreeSmartphoneGSMHZIface* dbus_service_device_free_smartphone_gsm_hz_parent_iface = NULL;
static FreeSmartphoneGSMMonitorIface* dbus_service_device_free_smartphone_gsm_monitor_parent_iface = NULL;
static FreeSmartphoneGSMVoiceMailIface* dbus_service_device_free_smartphone_gsm_voice_mail_parent_iface = NULL;
static GType dbus_service_device_type_id = 0;
static gpointer dbus_service_resource_parent_class = NULL;
extern DBusServiceDevice* device;
static GType dbus_service_resource_type_id = 0;
DBusServiceDevice* device = NULL;
extern DBusServiceResource* resource;
DBusServiceResource* resource = NULL;
extern gboolean running;
gboolean running = FALSE;

#define DBUS_SERVICE_MODULE_NAME "fsogsm.dbus_service"
GType dbus_service_device_get_type (void) G_GNUC_CONST;
GType dbus_service_device_register_type (GTypeModule * module);
enum  {
	DBUS_SERVICE_DEVICE_DUMMY_PROPERTY
};
DBusServiceDevice* dbus_service_device_new (FsoFrameworkSubsystem* subsystem);
DBusServiceDevice* dbus_service_device_construct (GType object_type, FsoFrameworkSubsystem* subsystem);
static void dbus_service_device_onModemHangup (DBusServiceDevice* self);
static void _dbus_service_device_onModemHangup_fso_gsm_modem_hangup (FsoGsmModem* _sender, gpointer self);
static gchar* dbus_service_device_real_repr (FsoFrameworkAbstractObject* base);
static void dbus_service_device_checkAvailability (DBusServiceDevice* self, FsoGsmModemStatus required, GError** error);
const gchar* fso_gsm_modem_status_to_string (FsoGsmModemStatus self);
static gboolean __lambda0_ (DBusServiceDevice* self);
static void dbus_service_device_onModemHangupAsync (DBusServiceDevice* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void dbus_service_device_onModemHangupAsync_finish (DBusServiceDevice* self, GAsyncResult* _res_);
static gboolean ___lambda0__gsource_func (gpointer self);
static void dbus_service_device_onModemHangupAsync_data_free (gpointer _data);
static gboolean dbus_service_device_onModemHangupAsync_co (dbus_service_device_onModemHangupAsyncData* _data_);
void dbus_service_device_enable (DBusServiceDevice* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
gboolean dbus_service_device_enable_finish (DBusServiceDevice* self, GAsyncResult* _res_);
static void dbus_service_device_onModemHangupAsync_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_enable_data_free (gpointer _data);
static gboolean dbus_service_device_enable_co (DbusServiceDeviceEnableData* _data_);
static void dbus_service_device_enable_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_disable_data_free (gpointer _data);
void dbus_service_device_disable (DBusServiceDevice* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
void dbus_service_device_disable_finish (DBusServiceDevice* self, GAsyncResult* _res_);
static gboolean dbus_service_device_disable_co (DbusServiceDeviceDisableData* _data_);
static void dbus_service_device_disable_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_suspend_data_free (gpointer _data);
void dbus_service_device_suspend (DBusServiceDevice* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
void dbus_service_device_suspend_finish (DBusServiceDevice* self, GAsyncResult* _res_);
static gboolean dbus_service_device_suspend_co (DbusServiceDeviceSuspendData* _data_);
static void dbus_service_device_suspend_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_resume_data_free (gpointer _data);
void dbus_service_device_resume (DBusServiceDevice* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
void dbus_service_device_resume_finish (DBusServiceDevice* self, GAsyncResult* _res_);
static gboolean dbus_service_device_resume_co (DbusServiceDeviceResumeData* _data_);
static void dbus_service_device_resume_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_info_data_free (gpointer _data);
static void dbus_service_device_real_get_info (FreeSmartphoneInfo* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_info_co (DbusServiceDeviceGetInfoData* _data_);
static void dbus_service_device_get_info_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_current_time_data_free (gpointer _data);
static void dbus_service_device_real_get_current_time (FreeSmartphoneDeviceRealtimeClock* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_current_time_co (DbusServiceDeviceGetCurrentTimeData* _data_);
static void dbus_service_device_get_current_time_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_set_current_time_data_free (gpointer _data);
static void dbus_service_device_real_set_current_time (FreeSmartphoneDeviceRealtimeClock* base, gint seconds_since_epoch, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_set_current_time_co (DbusServiceDeviceSetCurrentTimeData* _data_);
static void dbus_service_device_set_current_time_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_wakeup_time_data_free (gpointer _data);
static void dbus_service_device_real_get_wakeup_time (FreeSmartphoneDeviceRealtimeClock* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_wakeup_time_co (DbusServiceDeviceGetWakeupTimeData* _data_);
static void dbus_service_device_get_wakeup_time_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_set_wakeup_time_data_free (gpointer _data);
static void dbus_service_device_real_set_wakeup_time (FreeSmartphoneDeviceRealtimeClock* base, gint seconds_since_epoch, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_set_wakeup_time_co (DbusServiceDeviceSetWakeupTimeData* _data_);
static void dbus_service_device_set_wakeup_time_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_power_status_data_free (gpointer _data);
static void dbus_service_device_real_get_power_status (FreeSmartphoneDevicePowerSupply* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_power_status_co (DbusServiceDeviceGetPowerStatusData* _data_);
static void dbus_service_device_get_power_status_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_capacity_data_free (gpointer _data);
static void dbus_service_device_real_get_capacity (FreeSmartphoneDevicePowerSupply* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_capacity_co (DbusServiceDeviceGetCapacityData* _data_);
static void dbus_service_device_get_capacity_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_debug_command_data_free (gpointer _data);
static void dbus_service_device_real_debug_command (FreeSmartphoneGSMDebug* base, const gchar* command, const gchar* channel, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_debug_command_co (DbusServiceDeviceDebugCommandData* _data_);
static void dbus_service_device_debug_command_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_debug_inject_response_data_free (gpointer _data);
static void dbus_service_device_real_debug_inject_response (FreeSmartphoneGSMDebug* base, const gchar* response, const gchar* channel, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_debug_inject_response_co (DbusServiceDeviceDebugInjectResponseData* _data_);
static void dbus_service_device_debug_inject_response_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_debug_ping_data_free (gpointer _data);
static void dbus_service_device_real_debug_ping (FreeSmartphoneGSMDebug* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_debug_ping_co (DbusServiceDeviceDebugPingData* _data_);
static void dbus_service_device_debug_ping_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_functionality_data_free (gpointer _data);
static void dbus_service_device_real_get_functionality (FreeSmartphoneGSMDevice* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_functionality_co (DbusServiceDeviceGetFunctionalityData* _data_);
static void dbus_service_device_get_functionality_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_features_data_free (gpointer _data);
static void dbus_service_device_real_get_features (FreeSmartphoneGSMDevice* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_features_co (DbusServiceDeviceGetFeaturesData* _data_);
static void dbus_service_device_get_features_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_microphone_muted_data_free (gpointer _data);
static void dbus_service_device_real_get_microphone_muted (FreeSmartphoneGSMDevice* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_microphone_muted_co (DbusServiceDeviceGetMicrophoneMutedData* _data_);
static void dbus_service_device_get_microphone_muted_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_speaker_volume_data_free (gpointer _data);
static void dbus_service_device_real_get_speaker_volume (FreeSmartphoneGSMDevice* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_speaker_volume_co (DbusServiceDeviceGetSpeakerVolumeData* _data_);
static void dbus_service_device_get_speaker_volume_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_set_functionality_data_free (gpointer _data);
static void dbus_service_device_real_set_functionality (FreeSmartphoneGSMDevice* base, const gchar* level, gboolean autoregister, const gchar* pin, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_set_functionality_co (DbusServiceDeviceSetFunctionalityData* _data_);
static void dbus_service_device_set_functionality_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_set_microphone_muted_data_free (gpointer _data);
static void dbus_service_device_real_set_microphone_muted (FreeSmartphoneGSMDevice* base, gboolean muted, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_set_microphone_muted_co (DbusServiceDeviceSetMicrophoneMutedData* _data_);
static void dbus_service_device_set_microphone_muted_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_set_speaker_volume_data_free (gpointer _data);
static void dbus_service_device_real_set_speaker_volume (FreeSmartphoneGSMDevice* base, gint volume, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_set_speaker_volume_co (DbusServiceDeviceSetSpeakerVolumeData* _data_);
static void dbus_service_device_set_speaker_volume_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_device_status_data_free (gpointer _data);
static void dbus_service_device_real_get_device_status (FreeSmartphoneGSMDevice* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_device_status_co (DbusServiceDeviceGetDeviceStatusData* _data_);
static void dbus_service_device_real_change_auth_code_data_free (gpointer _data);
static void dbus_service_device_real_change_auth_code (FreeSmartphoneGSMSIM* base, const gchar* old_pin, const gchar* new_pin, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_change_auth_code_co (DbusServiceDeviceChangeAuthCodeData* _data_);
static void dbus_service_device_change_auth_code_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_delete_entry_data_free (gpointer _data);
static void dbus_service_device_real_delete_entry (FreeSmartphoneGSMSIM* base, const gchar* category, gint index, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_delete_entry_co (DbusServiceDeviceDeleteEntryData* _data_);
static void dbus_service_device_delete_entry_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_delete_message_data_free (gpointer _data);
static void dbus_service_device_real_delete_message (FreeSmartphoneGSMSIM* base, gint index, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_delete_message_co (DbusServiceDeviceDeleteMessageData* _data_);
static void dbus_service_device_delete_message_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_auth_code_required_data_free (gpointer _data);
static void dbus_service_device_real_get_auth_code_required (FreeSmartphoneGSMSIM* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_auth_code_required_co (DbusServiceDeviceGetAuthCodeRequiredData* _data_);
static void dbus_service_device_get_auth_code_required_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_auth_status_data_free (gpointer _data);
static void dbus_service_device_real_get_auth_status (FreeSmartphoneGSMSIM* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_auth_status_co (DbusServiceDeviceGetAuthStatusData* _data_);
static void dbus_service_device_get_auth_status_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void _vala_FreeSmartphoneGSMSIMHomeZone_array_free (FreeSmartphoneGSMSIMHomeZone* array, gint array_length);
static void dbus_service_device_real_get_home_zone_parameters_data_free (gpointer _data);
static void dbus_service_device_real_get_home_zone_parameters (FreeSmartphoneGSMSIM* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_home_zone_parameters_co (DbusServiceDeviceGetHomeZoneParametersData* _data_);
static void dbus_service_device_real_get_phonebook_info_data_free (gpointer _data);
static void dbus_service_device_real_get_phonebook_info (FreeSmartphoneGSMSIM* base, const gchar* category, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_phonebook_info_co (DbusServiceDeviceGetPhonebookInfoData* _data_);
static void dbus_service_device_get_phonebook_info_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_service_center_number_data_free (gpointer _data);
static void dbus_service_device_real_get_service_center_number (FreeSmartphoneGSMSIM* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_service_center_number_co (DbusServiceDeviceGetServiceCenterNumberData* _data_);
static void dbus_service_device_get_service_center_number_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_sim_info_data_free (gpointer _data);
static void dbus_service_device_real_get_sim_info (FreeSmartphoneGSMSIM* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_sim_info_co (DbusServiceDeviceGetSimInfoData* _data_);
static void dbus_service_device_get_sim_info_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_unlock_counters_data_free (gpointer _data);
static void dbus_service_device_real_get_unlock_counters (FreeSmartphoneGSMSIM* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_unlock_counters_co (DbusServiceDeviceGetUnlockCountersData* _data_);
static void dbus_service_device_get_unlock_counters_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_retrieve_message_data_free (gpointer _data);
static void dbus_service_device_real_retrieve_message (FreeSmartphoneGSMSIM* base, gint index, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_retrieve_message_co (DbusServiceDeviceRetrieveMessageData* _data_);
static void dbus_service_device_retrieve_message_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void _vala_FreeSmartphoneGSMSIMEntry_array_free (FreeSmartphoneGSMSIMEntry* array, gint array_length);
static void dbus_service_device_real_retrieve_phonebook_data_free (gpointer _data);
static void dbus_service_device_real_retrieve_phonebook (FreeSmartphoneGSMSIM* base, const gchar* category, gint mindex, gint maxdex, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_retrieve_phonebook_co (DbusServiceDeviceRetrievePhonebookData* _data_);
static void dbus_service_device_retrieve_phonebook_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static FreeSmartphoneGSMSIMEntry* _vala_array_dup1 (FreeSmartphoneGSMSIMEntry* self, int length);
static void dbus_service_device_real_send_auth_code_data_free (gpointer _data);
static void dbus_service_device_real_send_auth_code (FreeSmartphoneGSMSIM* base, const gchar* pin, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_send_auth_code_co (DbusServiceDeviceSendAuthCodeData* _data_);
static void dbus_service_device_send_auth_code_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_send_generic_sim_command_data_free (gpointer _data);
static void dbus_service_device_real_send_generic_sim_command (FreeSmartphoneGSMSIM* base, const gchar* command, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_send_generic_sim_command_co (DbusServiceDeviceSendGenericSimCommandData* _data_);
static void dbus_service_device_real_send_restricted_sim_command_data_free (gpointer _data);
static void dbus_service_device_real_send_restricted_sim_command (FreeSmartphoneGSMSIM* base, gint command, gint fileid, gint p1, gint p2, gint p3, const gchar* data, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_send_restricted_sim_command_co (DbusServiceDeviceSendRestrictedSimCommandData* _data_);
static void dbus_service_device_real_send_stored_message_data_free (gpointer _data);
static void dbus_service_device_real_send_stored_message (FreeSmartphoneGSMSIM* base, gint index, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_send_stored_message_co (DbusServiceDeviceSendStoredMessageData* _data_);
static void dbus_service_device_send_stored_message_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_set_auth_code_required_data_free (gpointer _data);
static void dbus_service_device_real_set_auth_code_required (FreeSmartphoneGSMSIM* base, gboolean check, const gchar* pin, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_set_auth_code_required_co (DbusServiceDeviceSetAuthCodeRequiredData* _data_);
static void dbus_service_device_set_auth_code_required_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_set_service_center_number_data_free (gpointer _data);
static void dbus_service_device_real_set_service_center_number (FreeSmartphoneGSMSIM* base, const gchar* number, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_set_service_center_number_co (DbusServiceDeviceSetServiceCenterNumberData* _data_);
static void dbus_service_device_set_service_center_number_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_store_entry_data_free (gpointer _data);
static void dbus_service_device_real_store_entry (FreeSmartphoneGSMSIM* base, const gchar* category, gint index, const gchar* name, const gchar* number, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_store_entry_co (DbusServiceDeviceStoreEntryData* _data_);
static void dbus_service_device_store_entry_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_store_message_data_free (gpointer _data);
static void dbus_service_device_real_store_message (FreeSmartphoneGSMSIM* base, const gchar* recipient_number, const gchar* contents, GHashTable* properties, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_store_message_co (DbusServiceDeviceStoreMessageData* _data_);
static void dbus_service_device_store_message_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_unlock_data_free (gpointer _data);
static void dbus_service_device_real_unlock (FreeSmartphoneGSMSIM* base, const gchar* puk, const gchar* new_pin, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_unlock_co (DbusServiceDeviceUnlockData* _data_);
static void dbus_service_device_unlock_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_size_for_text_message_data_free (gpointer _data);
static void dbus_service_device_real_get_size_for_text_message (FreeSmartphoneGSMSMS* base, const gchar* contents, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_size_for_text_message_co (DbusServiceDeviceGetSizeForTextMessageData* _data_);
static void dbus_service_device_get_size_for_text_message_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void _vala_FreeSmartphoneGSMSIMMessage_array_free (FreeSmartphoneGSMSIMMessage* array, gint array_length);
static void dbus_service_device_real_retrieve_text_messages_data_free (gpointer _data);
static void dbus_service_device_real_retrieve_text_messages (FreeSmartphoneGSMSMS* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_retrieve_text_messages_co (DbusServiceDeviceRetrieveTextMessagesData* _data_);
static void dbus_service_device_retrieve_text_messages_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static FreeSmartphoneGSMSIMMessage* _vala_array_dup2 (FreeSmartphoneGSMSIMMessage* self, int length);
static void dbus_service_device_real_send_text_message_data_free (gpointer _data);
static void dbus_service_device_real_send_text_message (FreeSmartphoneGSMSMS* base, const gchar* recipient_number, const gchar* contents, gboolean want_report, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_send_text_message_co (DbusServiceDeviceSendTextMessageData* _data_);
static void dbus_service_device_send_text_message_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_disable_call_forwarding_data_free (gpointer _data);
static void dbus_service_device_real_disable_call_forwarding (FreeSmartphoneGSMNetwork* base, const gchar* reason, const gchar* class_, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_disable_call_forwarding_co (DbusServiceDeviceDisableCallForwardingData* _data_);
static void dbus_service_device_real_enable_call_forwarding_data_free (gpointer _data);
static void dbus_service_device_real_enable_call_forwarding (FreeSmartphoneGSMNetwork* base, const gchar* reason, const gchar* class_, const gchar* number, gint timeout, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_enable_call_forwarding_co (DbusServiceDeviceEnableCallForwardingData* _data_);
static void dbus_service_device_real_get_call_forwarding_data_free (gpointer _data);
static void dbus_service_device_real_get_call_forwarding (FreeSmartphoneGSMNetwork* base, const gchar* reason, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_call_forwarding_co (DbusServiceDeviceGetCallForwardingData* _data_);
static void dbus_service_device_real_get_calling_identification_data_free (gpointer _data);
static void dbus_service_device_real_get_calling_identification (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_calling_identification_co (DbusServiceDeviceGetCallingIdentificationData* _data_);
static void dbus_service_device_get_calling_identification_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_time_report_data_free (gpointer _data);
static void dbus_service_device_real_get_time_report (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_time_report_co (DbusServiceDeviceGetTimeReportData* _data_);
static void dbus_service_device_real_get_signal_strength_data_free (gpointer _data);
static void dbus_service_device_real_get_signal_strength (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_signal_strength_co (DbusServiceDeviceGetSignalStrengthData* _data_);
static void dbus_service_device_get_signal_strength_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_status_data_free (gpointer _data);
static void dbus_service_device_real_get_status (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_status_co (DbusServiceDeviceGetStatusData* _data_);
static void dbus_service_device_get_status_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void _vala_FreeSmartphoneGSMNetworkProvider_array_free (FreeSmartphoneGSMNetworkProvider* array, gint array_length);
static void dbus_service_device_real_list_providers_data_free (gpointer _data);
static void dbus_service_device_real_list_providers (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_list_providers_co (DbusServiceDeviceListProvidersData* _data_);
static void dbus_service_device_list_providers_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static FreeSmartphoneGSMNetworkProvider* _vala_array_dup3 (FreeSmartphoneGSMNetworkProvider* self, int length);
static void dbus_service_device_real_register__data_free (gpointer _data);
static void dbus_service_device_real_register_ (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_register__co (DbusServiceDeviceRegisterData* _data_);
static void dbus_service_device_register__ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_register_with_provider_data_free (gpointer _data);
static void dbus_service_device_real_register_with_provider (FreeSmartphoneGSMNetwork* base, const gchar* operator_code, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_register_with_provider_co (DbusServiceDeviceRegisterWithProviderData* _data_);
static void dbus_service_device_register_with_provider_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_send_ussd_request_data_free (gpointer _data);
static void dbus_service_device_real_send_ussd_request (FreeSmartphoneGSMNetwork* base, const gchar* request, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_send_ussd_request_co (DbusServiceDeviceSendUssdRequestData* _data_);
static void dbus_service_device_send_ussd_request_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_set_calling_identification_data_free (gpointer _data);
static void dbus_service_device_real_set_calling_identification (FreeSmartphoneGSMNetwork* base, FreeSmartphoneGSMCallingIdentificationStatus status, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_set_calling_identification_co (DbusServiceDeviceSetCallingIdentificationData* _data_);
static void dbus_service_device_set_calling_identification_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_unregister_data_free (gpointer _data);
static void dbus_service_device_real_unregister (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_unregister_co (DbusServiceDeviceUnregisterData* _data_);
static void dbus_service_device_unregister_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_activate_data_free (gpointer _data);
static void dbus_service_device_real_activate (FreeSmartphoneGSMCall* base, gint id, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_activate_co (DbusServiceDeviceActivateData* _data_);
static void dbus_service_device_activate_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_activate_conference_data_free (gpointer _data);
static void dbus_service_device_real_activate_conference (FreeSmartphoneGSMCall* base, gint id, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_activate_conference_co (DbusServiceDeviceActivateConferenceData* _data_);
static void dbus_service_device_real_emergency_data_free (gpointer _data);
static void dbus_service_device_real_emergency (FreeSmartphoneGSMCall* base, const gchar* number, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_emergency_co (DbusServiceDeviceEmergencyData* _data_);
static void dbus_service_device_real_hold_active_data_free (gpointer _data);
static void dbus_service_device_real_hold_active (FreeSmartphoneGSMCall* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_hold_active_co (DbusServiceDeviceHoldActiveData* _data_);
static void dbus_service_device_hold_active_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_initiate_data_free (gpointer _data);
static void dbus_service_device_real_initiate (FreeSmartphoneGSMCall* base, const gchar* number, const gchar* ctype, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_initiate_co (DbusServiceDeviceInitiateData* _data_);
static void dbus_service_device_initiate_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_join_data_free (gpointer _data);
static void dbus_service_device_real_join (FreeSmartphoneGSMCall* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_join_co (DbusServiceDeviceJoinData* _data_);
static void _vala_FreeSmartphoneGSMCallDetail_array_free (FreeSmartphoneGSMCallDetail* array, gint array_length);
static void dbus_service_device_real_list_calls_data_free (gpointer _data);
static void dbus_service_device_real_list_calls (FreeSmartphoneGSMCall* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_list_calls_co (DbusServiceDeviceListCallsData* _data_);
static void dbus_service_device_list_calls_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static FreeSmartphoneGSMCallDetail* _vala_array_dup4 (FreeSmartphoneGSMCallDetail* self, int length);
static void dbus_service_device_real_release_data_free (gpointer _data);
static void dbus_service_device_real_release (FreeSmartphoneGSMCall* base, gint id, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_release_co (DbusServiceDeviceReleaseData* _data_);
static void dbus_service_device_release_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_release_all_data_free (gpointer _data);
static void dbus_service_device_real_release_all (FreeSmartphoneGSMCall* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_release_all_co (DbusServiceDeviceReleaseAllData* _data_);
static void dbus_service_device_release_all_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_release_held_data_free (gpointer _data);
static void dbus_service_device_real_release_held (FreeSmartphoneGSMCall* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_release_held_co (DbusServiceDeviceReleaseHeldData* _data_);
static void dbus_service_device_real_send_dtmf_data_free (gpointer _data);
static void dbus_service_device_real_send_dtmf (FreeSmartphoneGSMCall* base, const gchar* tones, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_send_dtmf_co (DbusServiceDeviceSendDtmfData* _data_);
static void dbus_service_device_send_dtmf_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_transfer_data_free (gpointer _data);
static void dbus_service_device_real_transfer (FreeSmartphoneGSMCall* base, const gchar* number, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_transfer_co (DbusServiceDeviceTransferData* _data_);
static void dbus_service_device_real_activate_context_data_free (gpointer _data);
static void dbus_service_device_real_activate_context (FreeSmartphoneGSMPDP* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_activate_context_co (DbusServiceDeviceActivateContextData* _data_);
static void dbus_service_device_activate_context_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_deactivate_context_data_free (gpointer _data);
static void dbus_service_device_real_deactivate_context (FreeSmartphoneGSMPDP* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_deactivate_context_co (DbusServiceDeviceDeactivateContextData* _data_);
static void dbus_service_device_deactivate_context_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_context_status_data_free (gpointer _data);
static void dbus_service_device_real_get_context_status (FreeSmartphoneGSMPDP* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_context_status_co (DbusServiceDeviceGetContextStatusData* _data_);
static void dbus_service_device_real_get_credentials_data_free (gpointer _data);
static void dbus_service_device_real_get_credentials (FreeSmartphoneGSMPDP* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_credentials_co (DbusServiceDeviceGetCredentialsData* _data_);
static void dbus_service_device_get_credentials_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_roaming_allowed_data_free (gpointer _data);
static void dbus_service_device_real_get_roaming_allowed (FreeSmartphoneGSMPDP* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_roaming_allowed_co (DbusServiceDeviceGetRoamingAllowedData* _data_);
static void dbus_service_device_real_set_roaming_allowed_data_free (gpointer _data);
static void dbus_service_device_real_set_roaming_allowed (FreeSmartphoneGSMPDP* base, gboolean state, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_set_roaming_allowed_co (DbusServiceDeviceSetRoamingAllowedData* _data_);
static void dbus_service_device_set_roaming_allowed_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_internal_status_update_data_free (gpointer _data);
static void dbus_service_device_real_internal_status_update (FreeSmartphoneGSMPDP* base, const gchar* status, GHashTable* properties, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_internal_status_update_co (DbusServiceDeviceInternalStatusUpdateData* _data_);
static void dbus_service_device_internal_status_update_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_set_credentials_data_free (gpointer _data);
static void dbus_service_device_real_set_credentials (FreeSmartphoneGSMPDP* base, const gchar* apn, const gchar* username, const gchar* password, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_set_credentials_co (DbusServiceDeviceSetCredentialsData* _data_);
static void dbus_service_device_set_credentials_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_cell_broadcast_subscriptions_data_free (gpointer _data);
static void dbus_service_device_real_get_cell_broadcast_subscriptions (FreeSmartphoneGSMCB* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_cell_broadcast_subscriptions_co (DbusServiceDeviceGetCellBroadcastSubscriptionsData* _data_);
static void dbus_service_device_get_cell_broadcast_subscriptions_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_set_cell_broadcast_subscriptions_data_free (gpointer _data);
static void dbus_service_device_real_set_cell_broadcast_subscriptions (FreeSmartphoneGSMCB* base, const gchar* subscriptions, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_set_cell_broadcast_subscriptions_co (DbusServiceDeviceSetCellBroadcastSubscriptionsData* _data_);
static void dbus_service_device_set_cell_broadcast_subscriptions_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_home_zone_status_data_free (gpointer _data);
static void dbus_service_device_real_get_home_zone_status (FreeSmartphoneGSMHZ* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_home_zone_status_co (DbusServiceDeviceGetHomeZoneStatusData* _data_);
static void dbus_service_device_real_get_known_home_zones_data_free (gpointer _data);
static void dbus_service_device_real_get_known_home_zones (FreeSmartphoneGSMHZ* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_known_home_zones_co (DbusServiceDeviceGetKnownHomeZonesData* _data_);
static void dbus_service_device_real_get_serving_cell_information_data_free (gpointer _data);
static void dbus_service_device_real_get_serving_cell_information (FreeSmartphoneGSMMonitor* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_serving_cell_information_co (DbusServiceDeviceGetServingCellInformationData* _data_);
static void dbus_service_device_get_serving_cell_information_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_neighbour_cell_information_data_free (gpointer _data);
static void dbus_service_device_real_get_neighbour_cell_information (FreeSmartphoneGSMMonitor* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_neighbour_cell_information_co (DbusServiceDeviceGetNeighbourCellInformationData* _data_);
static void dbus_service_device_get_neighbour_cell_information_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static GHashTable** _vala_array_dup5 (GHashTable** self, int length);
static void dbus_service_device_real_get_voice_mailbox_number_data_free (gpointer _data);
static void dbus_service_device_real_get_voice_mailbox_number (FreeSmartphoneGSMVoiceMail* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_voice_mailbox_number_co (DbusServiceDeviceGetVoiceMailboxNumberData* _data_);
static void dbus_service_device_get_voice_mailbox_number_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_set_voice_mailbox_number_data_free (gpointer _data);
static void dbus_service_device_real_set_voice_mailbox_number (FreeSmartphoneGSMVoiceMail* base, const gchar* number, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_set_voice_mailbox_number_co (DbusServiceDeviceSetVoiceMailboxNumberData* _data_);
static void dbus_service_device_set_voice_mailbox_number_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_device_real_get_stored_voice_mails_data_free (gpointer _data);
static void dbus_service_device_real_get_stored_voice_mails (FreeSmartphoneGSMVoiceMail* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_device_real_get_stored_voice_mails_co (DbusServiceDeviceGetStoredVoiceMailsData* _data_);
static void dbus_service_device_finalize (GObject* obj);
GType dbus_service_resource_get_type (void) G_GNUC_CONST;
GType dbus_service_resource_register_type (GTypeModule * module);
enum  {
	DBUS_SERVICE_RESOURCE_DUMMY_PROPERTY
};
DBusServiceResource* dbus_service_resource_new (FsoFrameworkSubsystem* subsystem);
DBusServiceResource* dbus_service_resource_construct (GType object_type, FsoFrameworkSubsystem* subsystem);
static void dbus_service_resource_real_enableResource_data_free (gpointer _data);
static void dbus_service_resource_real_enableResource (FsoFrameworkAbstractDBusResource* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_resource_real_enableResource_co (dbus_service_resource_enableResourceData* _data_);
static void dbus_service_resource_enableResource_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_resource_real_disableResource_data_free (gpointer _data);
static void dbus_service_resource_real_disableResource (FsoFrameworkAbstractDBusResource* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_resource_real_disableResource_co (dbus_service_resource_disableResourceData* _data_);
static void dbus_service_resource_disableResource_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_resource_real_suspendResource_data_free (gpointer _data);
static void dbus_service_resource_real_suspendResource (FsoFrameworkAbstractDBusResource* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_resource_real_suspendResource_co (dbus_service_resource_suspendResourceData* _data_);
static void dbus_service_resource_suspendResource_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_resource_real_resumeResource_data_free (gpointer _data);
static void dbus_service_resource_real_resumeResource (FsoFrameworkAbstractDBusResource* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_resource_real_resumeResource_co (dbus_service_resource_resumeResourceData* _data_);
static void dbus_service_resource_resumeResource_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
static void dbus_service_resource_real_dependencies_data_free (gpointer _data);
static void dbus_service_resource_real_dependencies (FsoFrameworkAbstractDBusResource* base, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_resource_real_dependencies_co (DbusServiceResourceDependenciesData* _data_);
static void _g_free0_ (gpointer var);
static void _g_variant_unref0_ (gpointer var);
static GVariant* _variant_new1 (const gchar* value);
gchar* fso_factory_function (FsoFrameworkSubsystem* subsystem, GError** error);
void fso_shutdown_function (GError** error);
void async_helper (GAsyncReadyCallback _callback_, gpointer _user_data_);
void async_helper_finish (GAsyncResult* _res_);
static void async_helper_data_free (gpointer _data);
static gboolean async_helper_co (AsyncHelperData* _data_);
static void async_helper_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
void fso_register_function (GTypeModule* module);
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);


static const gchar* string_to_string (const gchar* self) {
	const gchar* result = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	result = self;
	return result;
}


static void _dbus_service_device_onModemHangup_fso_gsm_modem_hangup (FsoGsmModem* _sender, gpointer self) {
	dbus_service_device_onModemHangup (self);
}


DBusServiceDevice* dbus_service_device_construct (GType object_type, FsoFrameworkSubsystem* subsystem) {
	DBusServiceDevice * self = NULL;
	FsoFrameworkSmartKeyFile* _tmp0_;
	gchar* _tmp1_ = NULL;
	gchar* modemtype;
	gchar* typename = NULL;
	const gchar* _tmp2_;
	const gchar* _tmp3_;
	GQuark _tmp5_ = 0U;
	static GQuark _tmp4_label0 = 0;
	static GQuark _tmp4_label1 = 0;
	static GQuark _tmp4_label2 = 0;
	static GQuark _tmp4_label3 = 0;
	static GQuark _tmp4_label4 = 0;
	static GQuark _tmp4_label5 = 0;
	static GQuark _tmp4_label6 = 0;
	static GQuark _tmp4_label7 = 0;
	static GQuark _tmp4_label8 = 0;
	static GQuark _tmp4_label9 = 0;
	static GQuark _tmp4_label10 = 0;
	const gchar* _tmp22_;
	GType _tmp23_ = 0UL;
	GType _tmp24_;
	FsoFrameworkSubsystem* _tmp30_;
	FsoFrameworkSubsystem* _tmp31_;
	FsoFrameworkSubsystem* _tmp32_;
	FsoFrameworkSubsystem* _tmp33_;
	FsoFrameworkSubsystem* _tmp34_;
	FsoFrameworkSubsystem* _tmp35_;
	FsoFrameworkSubsystem* _tmp36_;
	FsoFrameworkSubsystem* _tmp37_;
	FsoFrameworkSubsystem* _tmp38_;
	FsoFrameworkSubsystem* _tmp39_;
	FsoFrameworkSubsystem* _tmp40_;
	FsoFrameworkSubsystem* _tmp41_;
	FsoFrameworkSubsystem* _tmp42_;
	FsoFrameworkSubsystem* _tmp43_;
	GType _tmp44_;
	GObject* _tmp45_ = NULL;
	GObject* _tmp46_;
	FsoGsmModem* _tmp47_;
	FsoGsmModem* _tmp48_;
	FsoFrameworkLogger* _tmp49_;
	const gchar* _tmp50_;
	const gchar* _tmp51_ = NULL;
	gchar* _tmp52_ = NULL;
	gchar* _tmp53_;
	g_return_val_if_fail (subsystem != NULL, NULL);
	self = (DBusServiceDevice*) fso_framework_abstract_object_construct (object_type);
	_tmp0_ = ((FsoFrameworkAbstractObject*) self)->config;
	_tmp1_ = fso_framework_smart_key_file_stringValue (_tmp0_, "fsogsm", "modem_type", "none");
	modemtype = _tmp1_;
	_tmp2_ = modemtype;
	_tmp3_ = _tmp2_;
	_tmp5_ = (NULL == _tmp3_) ? 0 : g_quark_from_string (_tmp3_);
	if (_tmp5_ == ((0 != _tmp4_label0) ? _tmp4_label0 : (_tmp4_label0 = g_quark_from_static_string ("cinterion_mc75")))) {
		switch (0) {
			default:
			{
				gchar* _tmp6_;
				_tmp6_ = g_strdup ("CinterionMc75Modem");
				_g_free0 (typename);
				typename = _tmp6_;
				break;
			}
		}
	} else if (_tmp5_ == ((0 != _tmp4_label1) ? _tmp4_label1 : (_tmp4_label1 = g_quark_from_static_string ("dummy")))) {
		switch (0) {
			default:
			{
				gchar* _tmp7_;
				_tmp7_ = g_strdup ("DummyModem");
				_g_free0 (typename);
				typename = _tmp7_;
				break;
			}
		}
	} else if (_tmp5_ == ((0 != _tmp4_label2) ? _tmp4_label2 : (_tmp4_label2 = g_quark_from_static_string ("freescale_neptune")))) {
		switch (0) {
			default:
			{
				gchar* _tmp8_;
				_tmp8_ = g_strdup ("FreescaleNeptuneModem");
				_g_free0 (typename);
				typename = _tmp8_;
				break;
			}
		}
	} else if (_tmp5_ == ((0 != _tmp4_label3) ? _tmp4_label3 : (_tmp4_label3 = g_quark_from_static_string ("nokia_isi")))) {
		switch (0) {
			default:
			{
				gchar* _tmp9_;
				_tmp9_ = g_strdup ("NokiaIsiModem");
				_g_free0 (typename);
				typename = _tmp9_;
				break;
			}
		}
	} else if (_tmp5_ == ((0 != _tmp4_label4) ? _tmp4_label4 : (_tmp4_label4 = g_quark_from_static_string ("singleline")))) {
		switch (0) {
			default:
			{
				gchar* _tmp10_;
				_tmp10_ = g_strdup ("SinglelineModem");
				_g_free0 (typename);
				typename = _tmp10_;
				break;
			}
		}
	} else if (_tmp5_ == ((0 != _tmp4_label5) ? _tmp4_label5 : (_tmp4_label5 = g_quark_from_static_string ("ti_calypso")))) {
		switch (0) {
			default:
			{
				gchar* _tmp11_;
				_tmp11_ = g_strdup ("TiCalypsoModem");
				_g_free0 (typename);
				typename = _tmp11_;
				break;
			}
		}
	} else if (_tmp5_ == ((0 != _tmp4_label6) ? _tmp4_label6 : (_tmp4_label6 = g_quark_from_static_string ("qualcomm_htc")))) {
		switch (0) {
			default:
			{
				gchar* _tmp12_;
				_tmp12_ = g_strdup ("QualcommHtcModem");
				_g_free0 (typename);
				typename = _tmp12_;
				break;
			}
		}
	} else if (_tmp5_ == ((0 != _tmp4_label7) ? _tmp4_label7 : (_tmp4_label7 = g_quark_from_static_string ("qualcomm_palm")))) {
		switch (0) {
			default:
			{
				gchar* _tmp13_;
				_tmp13_ = g_strdup ("QualcommPalmModem");
				_g_free0 (typename);
				typename = _tmp13_;
				break;
			}
		}
	} else if (_tmp5_ == ((0 != _tmp4_label8) ? _tmp4_label8 : (_tmp4_label8 = g_quark_from_static_string ("samsung")))) {
		switch (0) {
			default:
			{
				gchar* _tmp14_;
				_tmp14_ = g_strdup ("SamsungModem");
				_g_free0 (typename);
				typename = _tmp14_;
				break;
			}
		}
	} else if (_tmp5_ == ((0 != _tmp4_label9) ? _tmp4_label9 : (_tmp4_label9 = g_quark_from_static_string ("option_gtm601")))) {
		switch (0) {
			default:
			{
				gchar* _tmp15_;
				_tmp15_ = g_strdup ("Gtm601Modem");
				_g_free0 (typename);
				typename = _tmp15_;
				break;
			}
		}
	} else if (_tmp5_ == ((0 != _tmp4_label10) ? _tmp4_label10 : (_tmp4_label10 = g_quark_from_static_string ("phonesim")))) {
		switch (0) {
			default:
			{
				gchar* _tmp16_;
				_tmp16_ = g_strdup ("PhonesimModem");
				_g_free0 (typename);
				typename = _tmp16_;
				break;
			}
		}
	} else {
		switch (0) {
			default:
			{
				FsoFrameworkLogger* _tmp17_;
				const gchar* _tmp18_;
				const gchar* _tmp19_ = NULL;
				gchar* _tmp20_ = NULL;
				gchar* _tmp21_;
				_tmp17_ = ((FsoFrameworkAbstractObject*) self)->logger;
				_tmp18_ = modemtype;
				_tmp19_ = string_to_string (_tmp18_);
				_tmp20_ = g_strconcat ("Unsupported modem_type ", _tmp19_, NULL);
				_tmp21_ = _tmp20_;
				fso_framework_logger_error (_tmp17_, _tmp21_);
				_g_free0 (_tmp21_);
				_g_free0 (typename);
				_g_free0 (modemtype);
				return self;
			}
		}
	}
	_tmp22_ = typename;
	_tmp23_ = g_type_from_name (_tmp22_);
	dbus_service_device_modemclass = _tmp23_;
	_tmp24_ = dbus_service_device_modemclass;
	if (_tmp24_ == G_TYPE_INVALID) {
		FsoFrameworkLogger* _tmp25_;
		const gchar* _tmp26_;
		const gchar* _tmp27_ = NULL;
		gchar* _tmp28_ = NULL;
		gchar* _tmp29_;
		_tmp25_ = ((FsoFrameworkAbstractObject*) self)->logger;
		_tmp26_ = modemtype;
		_tmp27_ = string_to_string (_tmp26_);
		_tmp28_ = g_strconcat ("Can't find modem for modem_type ", _tmp27_, "; corresponding modem plugin loaded?", NULL);
		_tmp29_ = _tmp28_;
		fso_framework_logger_error (_tmp25_, _tmp29_);
		_g_free0 (_tmp29_);
		_g_free0 (typename);
		_g_free0 (modemtype);
		return self;
	}
	_tmp30_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp30_, FREE_SMARTPHONE_TYPE_INFO, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneInfo*) self);
	_tmp31_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp31_, FREE_SMARTPHONE_DEVICE_TYPE_REALTIME_CLOCK, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneDeviceRealtimeClock*) self);
	_tmp32_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp32_, FREE_SMARTPHONE_DEVICE_TYPE_POWER_SUPPLY, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneDevicePowerSupply*) self);
	_tmp33_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp33_, FREE_SMARTPHONE_GSM_TYPE_DEBUG, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneGSMDebug*) self);
	_tmp34_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp34_, FREE_SMARTPHONE_GSM_TYPE_DEVICE, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneGSMDevice*) self);
	_tmp35_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp35_, FREE_SMARTPHONE_GSM_TYPE_SIM, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneGSMSIM*) self);
	_tmp36_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp36_, FREE_SMARTPHONE_GSM_TYPE_SMS, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneGSMSMS*) self);
	_tmp37_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp37_, FREE_SMARTPHONE_GSM_TYPE_NETWORK, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneGSMNetwork*) self);
	_tmp38_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp38_, FREE_SMARTPHONE_GSM_TYPE_CALL, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneGSMCall*) self);
	_tmp39_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp39_, FREE_SMARTPHONE_GSM_TYPE_PDP, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneGSMPDP*) self);
	_tmp40_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp40_, FREE_SMARTPHONE_GSM_TYPE_CB, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneGSMCB*) self);
	_tmp41_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp41_, FREE_SMARTPHONE_GSM_TYPE_HZ, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneGSMHZ*) self);
	_tmp42_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp42_, FREE_SMARTPHONE_GSM_TYPE_MONITOR, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneGSMMonitor*) self);
	_tmp43_ = subsystem;
	fso_framework_subsystem_registerObjectForService (_tmp43_, FREE_SMARTPHONE_GSM_TYPE_VOICE_MAIL, (GBoxedCopyFunc) g_object_ref, g_object_unref, FSO_FRAMEWORK_GSM_ServiceDBusName, FSO_FRAMEWORK_GSM_DeviceServicePath, (FreeSmartphoneGSMVoiceMail*) self);
	_tmp44_ = dbus_service_device_modemclass;
	_tmp45_ = g_object_new (_tmp44_, NULL);
	_tmp46_ = G_IS_INITIALLY_UNOWNED (_tmp45_) ? g_object_ref_sink (_tmp45_) : _tmp45_;
	_g_object_unref0 (dbus_service_device_modem);
	dbus_service_device_modem = FSO_GSM_MODEM (_tmp46_);
	_tmp47_ = dbus_service_device_modem;
	fso_gsm_modem_set_parent (_tmp47_, (GObject*) self);
	_tmp48_ = dbus_service_device_modem;
	g_signal_connect_object (_tmp48_, "hangup", (GCallback) _dbus_service_device_onModemHangup_fso_gsm_modem_hangup, self, 0);
	_tmp49_ = ((FsoFrameworkAbstractObject*) self)->logger;
	_tmp50_ = modemtype;
	_tmp51_ = string_to_string (_tmp50_);
	_tmp52_ = g_strconcat ("Ready. Configured for modem ", _tmp51_, NULL);
	_tmp53_ = _tmp52_;
	fso_framework_logger_info (_tmp49_, _tmp53_);
	_g_free0 (_tmp53_);
	_g_free0 (typename);
	_g_free0 (modemtype);
	return self;
}


DBusServiceDevice* dbus_service_device_new (FsoFrameworkSubsystem* subsystem) {
	return dbus_service_device_construct (DBUS_SERVICE_TYPE_DEVICE, subsystem);
}


static gchar* dbus_service_device_real_repr (FsoFrameworkAbstractObject* base) {
	DBusServiceDevice * self;
	gchar* result = NULL;
	gchar* _tmp0_;
	self = (DBusServiceDevice*) base;
	_tmp0_ = g_strdup ("<>");
	result = _tmp0_;
	return result;
}


static void dbus_service_device_checkAvailability (DBusServiceDevice* self, FsoGsmModemStatus required, GError** error) {
	FsoGsmModem* _tmp0_;
	gboolean _tmp2_ = FALSE;
	FsoGsmModem* _tmp3_;
	FsoGsmModemStatus _tmp4_ = 0;
	FsoGsmModemStatus _tmp5_;
	gboolean _tmp8_;
	GError * _inner_error_ = NULL;
	g_return_if_fail (self != NULL);
	_tmp0_ = dbus_service_device_modem;
	if (_tmp0_ == NULL) {
		GError* _tmp1_;
		_tmp1_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_UNAVAILABLE, "There is no underlying hardware present... stop talking to a vapourwar" \
"e modem!");
		_inner_error_ = _tmp1_;
		if (_inner_error_->domain == FREE_SMARTPHONE_ERROR) {
			g_propagate_error (error, _inner_error_);
			return;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return;
		}
	}
	_tmp3_ = dbus_service_device_modem;
	_tmp4_ = fso_gsm_modem_status (_tmp3_);
	_tmp5_ = required;
	if (_tmp4_ < _tmp5_) {
		_tmp2_ = TRUE;
	} else {
		FsoGsmModem* _tmp6_;
		FsoGsmModemStatus _tmp7_ = 0;
		_tmp6_ = dbus_service_device_modem;
		_tmp7_ = fso_gsm_modem_status (_tmp6_);
		_tmp2_ = _tmp7_ >= FSO_GSM_MODEM_STATUS_SUSPENDING;
	}
	_tmp8_ = _tmp2_;
	if (_tmp8_) {
		FsoGsmModem* _tmp9_;
		FsoGsmModemStatus _tmp10_ = 0;
		GEnumValue* _tmp11_;
		gchar* _tmp12_ = NULL;
		gchar* _tmp13_;
		GError* _tmp14_;
		GError* _tmp15_;
		_tmp9_ = dbus_service_device_modem;
		_tmp10_ = fso_gsm_modem_status (_tmp9_);
		_tmp11_ = g_enum_get_value (g_type_class_ref (FSO_GSM_MODEM_TYPE_STATUS), _tmp10_);
		_tmp12_ = g_strconcat ("This function is not available while modem is in state ", (_tmp11_ != NULL) ? _tmp11_->value_name : NULL, NULL);
		_tmp13_ = _tmp12_;
		_tmp14_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_UNAVAILABLE, _tmp13_);
		_tmp15_ = _tmp14_;
		_g_free0 (_tmp13_);
		_inner_error_ = _tmp15_;
		if (_inner_error_->domain == FREE_SMARTPHONE_ERROR) {
			g_propagate_error (error, _inner_error_);
			return;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
			g_clear_error (&_inner_error_);
			return;
		}
	}
}


static gboolean __lambda0_ (DBusServiceDevice* self) {
	gboolean result = FALSE;
	dbus_service_device_onModemHangupAsync (self, NULL, NULL);
	result = FALSE;
	return result;
}


static gboolean ___lambda0__gsource_func (gpointer self) {
	gboolean result;
	result = __lambda0_ (self);
	return result;
}


static void dbus_service_device_onModemHangup (DBusServiceDevice* self) {
	FsoFrameworkLogger* _tmp0_;
	g_return_if_fail (self != NULL);
	_tmp0_ = ((FsoFrameworkAbstractObject*) self)->logger;
	fso_framework_logger_warning (_tmp0_, "Modem no longer responding; trying to reopen in 5 seconds");
	g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, (guint) 5, ___lambda0__gsource_func, g_object_ref (self), g_object_unref);
}


static void dbus_service_device_onModemHangupAsync_data_free (gpointer _data) {
	dbus_service_device_onModemHangupAsyncData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (dbus_service_device_onModemHangupAsyncData, _data_);
}


static gpointer _g_object_ref0 (gpointer self) {
	return self ? g_object_ref (self) : NULL;
}


static void dbus_service_device_onModemHangupAsync (DBusServiceDevice* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	dbus_service_device_onModemHangupAsyncData* _data_;
	DBusServiceDevice* _tmp0_;
	_data_ = g_slice_new0 (dbus_service_device_onModemHangupAsyncData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_onModemHangupAsync);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_onModemHangupAsync_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_onModemHangupAsync_co (_data_);
}


static void dbus_service_device_onModemHangupAsync_finish (DBusServiceDevice* self, GAsyncResult* _res_) {
	dbus_service_device_onModemHangupAsyncData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_onModemHangupAsync_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	dbus_service_device_onModemHangupAsyncData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_onModemHangupAsync_co (_data_);
}


static gboolean dbus_service_device_onModemHangupAsync_co (dbus_service_device_onModemHangupAsyncData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_state_ = 1;
	dbus_service_device_enable (_data_->self, dbus_service_device_onModemHangupAsync_ready, _data_);
	return FALSE;
	_state_1:
	_data_->_tmp0_ = FALSE;
	_data_->_tmp0_ = dbus_service_device_enable_finish (_data_->self, _data_->_res_);
	_data_->ok = _data_->_tmp0_;
	_data_->_tmp1_ = _data_->ok;
	if (!_data_->_tmp1_) {
		dbus_service_device_onModemHangup (_data_->self);
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_enable_data_free (gpointer _data) {
	DbusServiceDeviceEnableData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceEnableData, _data_);
}


void dbus_service_device_enable (DBusServiceDevice* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DbusServiceDeviceEnableData* _data_;
	DBusServiceDevice* _tmp0_;
	_data_ = g_slice_new0 (DbusServiceDeviceEnableData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_enable);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_enable_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_enable_co (_data_);
}


gboolean dbus_service_device_enable_finish (DBusServiceDevice* self, GAsyncResult* _res_) {
	gboolean result;
	DbusServiceDeviceEnableData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_enable_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceEnableData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_enable_co (_data_);
}


static gboolean dbus_service_device_enable_co (DbusServiceDeviceEnableData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_state_ = 1;
	fso_gsm_modem_open (_data_->_tmp0_, dbus_service_device_enable_ready, _data_);
	return FALSE;
	_state_1:
	_data_->_tmp1_ = FALSE;
	_data_->_tmp1_ = fso_gsm_modem_open_finish (_data_->_tmp0_, _data_->_res_);
	_data_->ok = _data_->_tmp1_;
	_data_->_tmp2_ = _data_->ok;
	if (!_data_->_tmp2_) {
		_data_->_tmp3_ = ((FsoFrameworkAbstractObject*) _data_->self)->logger;
		fso_framework_logger_error (_data_->_tmp3_, "Can't open modem");
		_data_->result = FALSE;
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		_data_->_tmp4_ = ((FsoFrameworkAbstractObject*) _data_->self)->logger;
		fso_framework_logger_info (_data_->_tmp4_, "Modem opened successfully");
		_data_->result = TRUE;
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_disable_data_free (gpointer _data) {
	DbusServiceDeviceDisableData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceDisableData, _data_);
}


void dbus_service_device_disable (DBusServiceDevice* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DbusServiceDeviceDisableData* _data_;
	DBusServiceDevice* _tmp0_;
	_data_ = g_slice_new0 (DbusServiceDeviceDisableData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_disable);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_disable_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_disable_co (_data_);
}


void dbus_service_device_disable_finish (DBusServiceDevice* self, GAsyncResult* _res_) {
	DbusServiceDeviceDisableData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_disable_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceDisableData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_disable_co (_data_);
}


static gboolean dbus_service_device_disable_co (DbusServiceDeviceDisableData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_state_ = 1;
	fso_gsm_modem_close (_data_->_tmp0_, dbus_service_device_disable_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_modem_close_finish (_data_->_tmp0_, _data_->_res_);
	_data_->_tmp1_ = ((FsoFrameworkAbstractObject*) _data_->self)->logger;
	fso_framework_logger_info (_data_->_tmp1_, "Modem closed successfully");
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_suspend_data_free (gpointer _data) {
	DbusServiceDeviceSuspendData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSuspendData, _data_);
}


void dbus_service_device_suspend (DBusServiceDevice* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DbusServiceDeviceSuspendData* _data_;
	DBusServiceDevice* _tmp0_;
	_data_ = g_slice_new0 (DbusServiceDeviceSuspendData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_suspend);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_suspend_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_suspend_co (_data_);
}


void dbus_service_device_suspend_finish (DBusServiceDevice* self, GAsyncResult* _res_) {
	DbusServiceDeviceSuspendData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_suspend_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSuspendData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_suspend_co (_data_);
}


static gboolean dbus_service_device_suspend_co (DbusServiceDeviceSuspendData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_state_ = 1;
	fso_gsm_modem_suspend (_data_->_tmp0_, dbus_service_device_suspend_ready, _data_);
	return FALSE;
	_state_1:
	_data_->_tmp1_ = FALSE;
	_data_->_tmp1_ = fso_gsm_modem_suspend_finish (_data_->_tmp0_, _data_->_res_);
	_data_->ok = _data_->_tmp1_;
	_data_->_tmp2_ = _data_->ok;
	if (_data_->_tmp2_) {
		_data_->_tmp3_ = ((FsoFrameworkAbstractObject*) _data_->self)->logger;
		fso_framework_logger_info (_data_->_tmp3_, "Modem suspended successfully");
	} else {
		_data_->_tmp4_ = ((FsoFrameworkAbstractObject*) _data_->self)->logger;
		fso_framework_logger_warning (_data_->_tmp4_, "Modem not suspended; prepare yourself for spurious wakeups");
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_resume_data_free (gpointer _data) {
	DbusServiceDeviceResumeData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceResumeData, _data_);
}


void dbus_service_device_resume (DBusServiceDevice* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DbusServiceDeviceResumeData* _data_;
	DBusServiceDevice* _tmp0_;
	_data_ = g_slice_new0 (DbusServiceDeviceResumeData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_resume);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_resume_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_resume_co (_data_);
}


void dbus_service_device_resume_finish (DBusServiceDevice* self, GAsyncResult* _res_) {
	DbusServiceDeviceResumeData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_resume_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceResumeData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_resume_co (_data_);
}


static gboolean dbus_service_device_resume_co (DbusServiceDeviceResumeData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_state_ = 1;
	fso_gsm_modem_resume (_data_->_tmp0_, dbus_service_device_resume_ready, _data_);
	return FALSE;
	_state_1:
	_data_->_tmp1_ = FALSE;
	_data_->_tmp1_ = fso_gsm_modem_resume_finish (_data_->_tmp0_, _data_->_res_);
	_data_->ok = _data_->_tmp1_;
	_data_->_tmp2_ = _data_->ok;
	if (_data_->_tmp2_) {
		_data_->_tmp3_ = ((FsoFrameworkAbstractObject*) _data_->self)->logger;
		fso_framework_logger_info (_data_->_tmp3_, "Modem resumed successfully");
	} else {
		_data_->_tmp4_ = ((FsoFrameworkAbstractObject*) _data_->self)->logger;
		fso_framework_logger_warning (_data_->_tmp4_, "Modem did not resume correctly");
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_info_data_free (gpointer _data) {
	DbusServiceDeviceGetInfoData* _data_;
	_data_ = _data;
	_g_hash_table_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetInfoData, _data_);
}


static void dbus_service_device_real_get_info (FreeSmartphoneInfo* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetInfoData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetInfoData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_info);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_info_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_info_co (_data_);
}


static GHashTable* dbus_service_device_real_get_info_finish (FreeSmartphoneInfo* base, GAsyncResult* _res_, GError** error) {
	GHashTable* result;
	DbusServiceDeviceGetInfoData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_get_info_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetInfoData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_info_co (_data_);
}


static gpointer _g_hash_table_ref0 (gpointer self) {
	return self ? g_hash_table_ref (self) : NULL;
}


static gboolean dbus_service_device_real_get_info_co (DbusServiceDeviceGetInfoData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEVICE_GET_INFORMATION, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDeviceGetInformation*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	{
		_data_->_tmp2_ = _data_->m;
		_data_->_state_ = 1;
		fso_gsm_device_get_information_run (_data_->_tmp2_, dbus_service_device_get_info_ready, _data_);
		return FALSE;
		_state_1:
		fso_gsm_device_get_information_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
		if (_data_->_inner_error_ != NULL) {
			if (_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) {
				goto __catch0_free_smartphone_gsm_error;
			}
			goto __finally0;
		}
	}
	goto __finally0;
	__catch0_free_smartphone_gsm_error:
	{
		_data_->e = _data_->_inner_error_;
		_data_->_inner_error_ = NULL;
		_data_->_tmp3_ = _data_->e;
		_data_->_tmp4_ = _data_->_tmp3_->message;
		_data_->_tmp5_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_SYSTEM_ERROR, _data_->_tmp4_);
		_data_->_inner_error_ = _data_->_tmp5_;
		_g_error_free0 (_data_->e);
		goto __finally0;
	}
	__finally0:
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp6_ = _data_->m;
	_data_->_tmp7_ = fso_gsm_device_get_information_get_info (_data_->_tmp6_);
	_data_->_tmp8_ = _data_->_tmp7_;
	_data_->_tmp9_ = _g_hash_table_ref0 (_data_->_tmp8_);
	_data_->result = _data_->_tmp9_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_current_time_data_free (gpointer _data) {
	DbusServiceDeviceGetCurrentTimeData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetCurrentTimeData, _data_);
}


static void dbus_service_device_real_get_current_time (FreeSmartphoneDeviceRealtimeClock* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetCurrentTimeData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetCurrentTimeData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_current_time);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_current_time_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_current_time_co (_data_);
}


static gint dbus_service_device_real_get_current_time_finish (FreeSmartphoneDeviceRealtimeClock* base, GAsyncResult* _res_, GError** error) {
	gint result;
	DbusServiceDeviceGetCurrentTimeData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return 0;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_get_current_time_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetCurrentTimeData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_current_time_co (_data_);
}


static gboolean dbus_service_device_real_get_current_time_co (DbusServiceDeviceGetCurrentTimeData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEVICE_GET_CURRENT_TIME, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDeviceGetCurrentTime*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	{
		_data_->_tmp2_ = _data_->m;
		_data_->_state_ = 1;
		fso_gsm_device_get_current_time_run (_data_->_tmp2_, dbus_service_device_get_current_time_ready, _data_);
		return FALSE;
		_state_1:
		fso_gsm_device_get_current_time_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
		if (_data_->_inner_error_ != NULL) {
			if (_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) {
				goto __catch1_free_smartphone_gsm_error;
			}
			goto __finally1;
		}
	}
	goto __finally1;
	__catch1_free_smartphone_gsm_error:
	{
		_data_->e = _data_->_inner_error_;
		_data_->_inner_error_ = NULL;
		_data_->_tmp3_ = _data_->e;
		_data_->_tmp4_ = _data_->_tmp3_->message;
		_data_->_tmp5_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_SYSTEM_ERROR, _data_->_tmp4_);
		_data_->_inner_error_ = _data_->_tmp5_;
		_g_error_free0 (_data_->e);
		goto __finally1;
	}
	__finally1:
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp6_ = _data_->m;
	_data_->_tmp7_ = fso_gsm_device_get_current_time_get_since_epoch (_data_->_tmp6_);
	_data_->_tmp8_ = _data_->_tmp7_;
	_data_->result = _data_->_tmp8_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_set_current_time_data_free (gpointer _data) {
	DbusServiceDeviceSetCurrentTimeData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSetCurrentTimeData, _data_);
}


static void dbus_service_device_real_set_current_time (FreeSmartphoneDeviceRealtimeClock* base, gint seconds_since_epoch, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSetCurrentTimeData* _data_;
	DBusServiceDevice* _tmp0_;
	gint _tmp1_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSetCurrentTimeData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_set_current_time);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_set_current_time_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = seconds_since_epoch;
	_data_->seconds_since_epoch = _tmp1_;
	dbus_service_device_real_set_current_time_co (_data_);
}


static void dbus_service_device_real_set_current_time_finish (FreeSmartphoneDeviceRealtimeClock* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSetCurrentTimeData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_set_current_time_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSetCurrentTimeData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_set_current_time_co (_data_);
}


static gboolean dbus_service_device_real_set_current_time_co (DbusServiceDeviceSetCurrentTimeData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEVICE_SET_CURRENT_TIME, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDeviceSetCurrentTime*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	{
		_data_->_tmp2_ = _data_->m;
		_data_->_tmp3_ = _data_->seconds_since_epoch;
		_data_->_state_ = 1;
		fso_gsm_device_set_current_time_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_set_current_time_ready, _data_);
		return FALSE;
		_state_1:
		fso_gsm_device_set_current_time_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
		if (_data_->_inner_error_ != NULL) {
			if (_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) {
				goto __catch2_free_smartphone_gsm_error;
			}
			goto __finally2;
		}
	}
	goto __finally2;
	__catch2_free_smartphone_gsm_error:
	{
		_data_->e = _data_->_inner_error_;
		_data_->_inner_error_ = NULL;
		_data_->_tmp4_ = _data_->e;
		_data_->_tmp5_ = _data_->_tmp4_->message;
		_data_->_tmp6_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_SYSTEM_ERROR, _data_->_tmp5_);
		_data_->_inner_error_ = _data_->_tmp6_;
		_g_error_free0 (_data_->e);
		goto __finally2;
	}
	__finally2:
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_wakeup_time_data_free (gpointer _data) {
	DbusServiceDeviceGetWakeupTimeData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetWakeupTimeData, _data_);
}


static void dbus_service_device_real_get_wakeup_time (FreeSmartphoneDeviceRealtimeClock* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetWakeupTimeData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetWakeupTimeData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_wakeup_time);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_wakeup_time_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_wakeup_time_co (_data_);
}


static gint dbus_service_device_real_get_wakeup_time_finish (FreeSmartphoneDeviceRealtimeClock* base, GAsyncResult* _res_, GError** error) {
	gint result;
	DbusServiceDeviceGetWakeupTimeData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return 0;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_get_wakeup_time_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetWakeupTimeData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_wakeup_time_co (_data_);
}


static gboolean dbus_service_device_real_get_wakeup_time_co (DbusServiceDeviceGetWakeupTimeData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEVICE_GET_ALARM_TIME, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDeviceGetAlarmTime*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	{
		_data_->_tmp2_ = _data_->m;
		_data_->_state_ = 1;
		fso_gsm_device_get_alarm_time_run (_data_->_tmp2_, dbus_service_device_get_wakeup_time_ready, _data_);
		return FALSE;
		_state_1:
		fso_gsm_device_get_alarm_time_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
		if (_data_->_inner_error_ != NULL) {
			if (_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) {
				goto __catch3_free_smartphone_gsm_error;
			}
			goto __finally3;
		}
	}
	goto __finally3;
	__catch3_free_smartphone_gsm_error:
	{
		_data_->e = _data_->_inner_error_;
		_data_->_inner_error_ = NULL;
		_data_->_tmp3_ = _data_->e;
		_data_->_tmp4_ = _data_->_tmp3_->message;
		_data_->_tmp5_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_SYSTEM_ERROR, _data_->_tmp4_);
		_data_->_inner_error_ = _data_->_tmp5_;
		_g_error_free0 (_data_->e);
		goto __finally3;
	}
	__finally3:
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp6_ = _data_->m;
	_data_->_tmp7_ = fso_gsm_device_get_alarm_time_get_since_epoch (_data_->_tmp6_);
	_data_->_tmp8_ = _data_->_tmp7_;
	_data_->result = _data_->_tmp8_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_set_wakeup_time_data_free (gpointer _data) {
	DbusServiceDeviceSetWakeupTimeData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSetWakeupTimeData, _data_);
}


static void dbus_service_device_real_set_wakeup_time (FreeSmartphoneDeviceRealtimeClock* base, gint seconds_since_epoch, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSetWakeupTimeData* _data_;
	DBusServiceDevice* _tmp0_;
	gint _tmp1_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSetWakeupTimeData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_set_wakeup_time);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_set_wakeup_time_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = seconds_since_epoch;
	_data_->seconds_since_epoch = _tmp1_;
	dbus_service_device_real_set_wakeup_time_co (_data_);
}


static void dbus_service_device_real_set_wakeup_time_finish (FreeSmartphoneDeviceRealtimeClock* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSetWakeupTimeData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_set_wakeup_time_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSetWakeupTimeData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_set_wakeup_time_co (_data_);
}


static gboolean dbus_service_device_real_set_wakeup_time_co (DbusServiceDeviceSetWakeupTimeData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEVICE_SET_ALARM_TIME, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDeviceSetAlarmTime*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	{
		_data_->_tmp2_ = _data_->m;
		_data_->_tmp3_ = _data_->seconds_since_epoch;
		_data_->_state_ = 1;
		fso_gsm_device_set_alarm_time_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_set_wakeup_time_ready, _data_);
		return FALSE;
		_state_1:
		fso_gsm_device_set_alarm_time_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
		if (_data_->_inner_error_ != NULL) {
			if (_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) {
				goto __catch4_free_smartphone_gsm_error;
			}
			goto __finally4;
		}
	}
	goto __finally4;
	__catch4_free_smartphone_gsm_error:
	{
		_data_->e = _data_->_inner_error_;
		_data_->_inner_error_ = NULL;
		_data_->_tmp4_ = _data_->e;
		_data_->_tmp5_ = _data_->_tmp4_->message;
		_data_->_tmp6_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_SYSTEM_ERROR, _data_->_tmp5_);
		_data_->_inner_error_ = _data_->_tmp6_;
		_g_error_free0 (_data_->e);
		goto __finally4;
	}
	__finally4:
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp7_ = _data_->seconds_since_epoch;
	g_signal_emit_by_name ((FreeSmartphoneDeviceRealtimeClock*) _data_->self, "wakeup-time-changed", _data_->_tmp7_);
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_power_status_data_free (gpointer _data) {
	DbusServiceDeviceGetPowerStatusData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetPowerStatusData, _data_);
}


static void dbus_service_device_real_get_power_status (FreeSmartphoneDevicePowerSupply* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetPowerStatusData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetPowerStatusData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_power_status);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_power_status_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_power_status_co (_data_);
}


static FreeSmartphoneDevicePowerStatus dbus_service_device_real_get_power_status_finish (FreeSmartphoneDevicePowerSupply* base, GAsyncResult* _res_, GError** error) {
	FreeSmartphoneDevicePowerStatus result;
	DbusServiceDeviceGetPowerStatusData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return 0;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_get_power_status_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetPowerStatusData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_power_status_co (_data_);
}


static gboolean dbus_service_device_real_get_power_status_co (DbusServiceDeviceGetPowerStatusData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == G_DBUS_ERROR) || (_data_->_inner_error_->domain == G_IO_ERROR)) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEVICE_GET_POWER_STATUS, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDeviceGetPowerStatus*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == G_DBUS_ERROR) || (_data_->_inner_error_->domain == G_IO_ERROR)) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	{
		_data_->_tmp2_ = _data_->m;
		_data_->_state_ = 1;
		fso_gsm_device_get_power_status_run (_data_->_tmp2_, dbus_service_device_get_power_status_ready, _data_);
		return FALSE;
		_state_1:
		fso_gsm_device_get_power_status_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
		if (_data_->_inner_error_ != NULL) {
			goto __catch5_g_error;
		}
		_data_->_tmp3_ = _data_->m;
		_data_->_tmp4_ = fso_gsm_device_get_power_status_get_status (_data_->_tmp3_);
		_data_->_tmp5_ = _data_->_tmp4_;
		_data_->result = _data_->_tmp5_;
		_g_object_unref0 (_data_->m);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	goto __finally5;
	__catch5_g_error:
	{
		_data_->e = _data_->_inner_error_;
		_data_->_inner_error_ = NULL;
		_data_->result = FREE_SMARTPHONE_DEVICE_POWER_STATUS_UNKNOWN;
		_g_error_free0 (_data_->e);
		_g_object_unref0 (_data_->m);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	__finally5:
	if (((_data_->_inner_error_->domain == G_DBUS_ERROR) || (_data_->_inner_error_->domain == G_IO_ERROR)) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		_g_object_unref0 (_data_->m);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		_g_object_unref0 (_data_->m);
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_capacity_data_free (gpointer _data) {
	DbusServiceDeviceGetCapacityData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetCapacityData, _data_);
}


static void dbus_service_device_real_get_capacity (FreeSmartphoneDevicePowerSupply* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetCapacityData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetCapacityData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_capacity);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_capacity_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_capacity_co (_data_);
}


static gint dbus_service_device_real_get_capacity_finish (FreeSmartphoneDevicePowerSupply* base, GAsyncResult* _res_, GError** error) {
	gint result;
	DbusServiceDeviceGetCapacityData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return 0;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_get_capacity_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetCapacityData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_capacity_co (_data_);
}


static gboolean dbus_service_device_real_get_capacity_co (DbusServiceDeviceGetCapacityData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == G_DBUS_ERROR) || (_data_->_inner_error_->domain == G_IO_ERROR)) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEVICE_GET_POWER_STATUS, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDeviceGetPowerStatus*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if (((_data_->_inner_error_->domain == G_DBUS_ERROR) || (_data_->_inner_error_->domain == G_IO_ERROR)) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	{
		_data_->_tmp2_ = _data_->m;
		_data_->_state_ = 1;
		fso_gsm_device_get_power_status_run (_data_->_tmp2_, dbus_service_device_get_capacity_ready, _data_);
		return FALSE;
		_state_1:
		fso_gsm_device_get_power_status_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
		if (_data_->_inner_error_ != NULL) {
			goto __catch6_g_error;
		}
		_data_->_tmp3_ = _data_->m;
		_data_->_tmp4_ = fso_gsm_device_get_power_status_get_level (_data_->_tmp3_);
		_data_->_tmp5_ = _data_->_tmp4_;
		_data_->result = _data_->_tmp5_;
		_g_object_unref0 (_data_->m);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	goto __finally6;
	__catch6_g_error:
	{
		_data_->e = _data_->_inner_error_;
		_data_->_inner_error_ = NULL;
		_data_->result = -1;
		_g_error_free0 (_data_->e);
		_g_object_unref0 (_data_->m);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	__finally6:
	if (((_data_->_inner_error_->domain == G_DBUS_ERROR) || (_data_->_inner_error_->domain == G_IO_ERROR)) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		_g_object_unref0 (_data_->m);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		_g_object_unref0 (_data_->m);
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_debug_command_data_free (gpointer _data) {
	DbusServiceDeviceDebugCommandData* _data_;
	_data_ = _data;
	_g_free0 (_data_->command);
	_g_free0 (_data_->channel);
	_g_free0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceDebugCommandData, _data_);
}


static void dbus_service_device_real_debug_command (FreeSmartphoneGSMDebug* base, const gchar* command, const gchar* channel, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceDebugCommandData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceDebugCommandData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_debug_command);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_debug_command_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = command;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->command = _tmp2_;
	_tmp3_ = channel;
	_tmp4_ = g_strdup (_tmp3_);
	_data_->channel = _tmp4_;
	dbus_service_device_real_debug_command_co (_data_);
}


static gchar* dbus_service_device_real_debug_command_finish (FreeSmartphoneGSMDebug* base, GAsyncResult* _res_, GError** error) {
	gchar* result;
	DbusServiceDeviceDebugCommandData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_debug_command_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceDebugCommandData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_debug_command_co (_data_);
}


static gboolean dbus_service_device_real_debug_command_co (DbusServiceDeviceDebugCommandData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEBUG_COMMAND, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDebugCommand*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->command;
	_data_->_tmp4_ = _data_->channel;
	_data_->_state_ = 1;
	fso_gsm_debug_command_run (_data_->_tmp2_, _data_->_tmp3_, _data_->_tmp4_, dbus_service_device_debug_command_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_debug_command_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp5_ = _data_->m;
	_data_->_tmp6_ = fso_gsm_debug_command_get_response (_data_->_tmp5_);
	_data_->_tmp7_ = _data_->_tmp6_;
	_data_->_tmp8_ = g_strdup (_data_->_tmp7_);
	_data_->result = _data_->_tmp8_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_debug_inject_response_data_free (gpointer _data) {
	DbusServiceDeviceDebugInjectResponseData* _data_;
	_data_ = _data;
	_g_free0 (_data_->response);
	_g_free0 (_data_->channel);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceDebugInjectResponseData, _data_);
}


static void dbus_service_device_real_debug_inject_response (FreeSmartphoneGSMDebug* base, const gchar* response, const gchar* channel, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceDebugInjectResponseData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceDebugInjectResponseData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_debug_inject_response);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_debug_inject_response_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = response;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->response = _tmp2_;
	_tmp3_ = channel;
	_tmp4_ = g_strdup (_tmp3_);
	_data_->channel = _tmp4_;
	dbus_service_device_real_debug_inject_response_co (_data_);
}


static void dbus_service_device_real_debug_inject_response_finish (FreeSmartphoneGSMDebug* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceDebugInjectResponseData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_debug_inject_response_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceDebugInjectResponseData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_debug_inject_response_co (_data_);
}


static gboolean dbus_service_device_real_debug_inject_response_co (DbusServiceDeviceDebugInjectResponseData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEBUG_INJECT_RESPONSE, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDebugInjectResponse*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->response;
	_data_->_tmp4_ = _data_->channel;
	_data_->_state_ = 1;
	fso_gsm_debug_inject_response_run (_data_->_tmp2_, _data_->_tmp3_, _data_->_tmp4_, dbus_service_device_debug_inject_response_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_debug_inject_response_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_debug_ping_data_free (gpointer _data) {
	DbusServiceDeviceDebugPingData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceDebugPingData, _data_);
}


static void dbus_service_device_real_debug_ping (FreeSmartphoneGSMDebug* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceDebugPingData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceDebugPingData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_debug_ping);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_debug_ping_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_debug_ping_co (_data_);
}


static void dbus_service_device_real_debug_ping_finish (FreeSmartphoneGSMDebug* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceDebugPingData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_debug_ping_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceDebugPingData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_debug_ping_co (_data_);
}


static gboolean dbus_service_device_real_debug_ping_co (DbusServiceDeviceDebugPingData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEBUG_PING, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDebugPing*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_debug_ping_run (_data_->_tmp2_, dbus_service_device_debug_ping_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_debug_ping_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_functionality_data_free (gpointer _data) {
	DbusServiceDeviceGetFunctionalityData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetFunctionalityData, _data_);
}


static void dbus_service_device_real_get_functionality (FreeSmartphoneGSMDevice* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetFunctionalityData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetFunctionalityData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_functionality);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_functionality_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_functionality_co (_data_);
}


static void dbus_service_device_real_get_functionality_finish (FreeSmartphoneGSMDevice* base, GAsyncResult* _res_, gchar** level, gboolean* autoregister, gchar** pin, GError** error) {
	DbusServiceDeviceGetFunctionalityData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	if (level) {
		*level = _data_->level;
	} else {
		_g_free0 (_data_->level);
	}
	_data_->level = NULL;
	if (autoregister) {
		*autoregister = _data_->autoregister;
	}
	if (pin) {
		*pin = _data_->pin;
	} else {
		_g_free0 (_data_->pin);
	}
	_data_->pin = NULL;
}


static void dbus_service_device_get_functionality_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetFunctionalityData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_functionality_co (_data_);
}


static gboolean dbus_service_device_real_get_functionality_co (DbusServiceDeviceGetFunctionalityData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEVICE_GET_FUNCTIONALITY, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDeviceGetFunctionality*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_device_get_functionality_run (_data_->_tmp2_, dbus_service_device_get_functionality_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_device_get_functionality_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_device_get_functionality_get_level (_data_->_tmp3_);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->_tmp6_ = g_strdup (_data_->_tmp5_);
	_g_free0 (_data_->level);
	_data_->level = _data_->_tmp6_;
	_data_->_tmp7_ = _data_->m;
	_data_->_tmp8_ = fso_gsm_device_get_functionality_get_autoregister (_data_->_tmp7_);
	_data_->_tmp9_ = _data_->_tmp8_;
	_data_->autoregister = _data_->_tmp9_;
	_data_->_tmp10_ = _data_->m;
	_data_->_tmp11_ = fso_gsm_device_get_functionality_get_pin (_data_->_tmp10_);
	_data_->_tmp12_ = _data_->_tmp11_;
	_data_->_tmp13_ = g_strdup (_data_->_tmp12_);
	_g_free0 (_data_->pin);
	_data_->pin = _data_->_tmp13_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_features_data_free (gpointer _data) {
	DbusServiceDeviceGetFeaturesData* _data_;
	_data_ = _data;
	_g_hash_table_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetFeaturesData, _data_);
}


static void dbus_service_device_real_get_features (FreeSmartphoneGSMDevice* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetFeaturesData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetFeaturesData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_features);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_features_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_features_co (_data_);
}


static GHashTable* dbus_service_device_real_get_features_finish (FreeSmartphoneGSMDevice* base, GAsyncResult* _res_, GError** error) {
	GHashTable* result;
	DbusServiceDeviceGetFeaturesData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_get_features_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetFeaturesData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_features_co (_data_);
}


static gboolean dbus_service_device_real_get_features_co (DbusServiceDeviceGetFeaturesData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEVICE_GET_FEATURES, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDeviceGetFeatures*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_device_get_features_run (_data_->_tmp2_, dbus_service_device_get_features_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_device_get_features_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_device_get_features_get_features (_data_->_tmp3_);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->_tmp6_ = _g_hash_table_ref0 (_data_->_tmp5_);
	_data_->result = _data_->_tmp6_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_microphone_muted_data_free (gpointer _data) {
	DbusServiceDeviceGetMicrophoneMutedData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetMicrophoneMutedData, _data_);
}


static void dbus_service_device_real_get_microphone_muted (FreeSmartphoneGSMDevice* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetMicrophoneMutedData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetMicrophoneMutedData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_microphone_muted);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_microphone_muted_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_microphone_muted_co (_data_);
}


static gboolean dbus_service_device_real_get_microphone_muted_finish (FreeSmartphoneGSMDevice* base, GAsyncResult* _res_, GError** error) {
	gboolean result;
	DbusServiceDeviceGetMicrophoneMutedData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return FALSE;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_get_microphone_muted_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetMicrophoneMutedData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_microphone_muted_co (_data_);
}


static gboolean dbus_service_device_real_get_microphone_muted_co (DbusServiceDeviceGetMicrophoneMutedData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEVICE_GET_MICROPHONE_MUTED, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDeviceGetMicrophoneMuted*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_device_get_microphone_muted_run (_data_->_tmp2_, dbus_service_device_get_microphone_muted_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_device_get_microphone_muted_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_device_get_microphone_muted_get_muted (_data_->_tmp3_);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->result = _data_->_tmp5_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_speaker_volume_data_free (gpointer _data) {
	DbusServiceDeviceGetSpeakerVolumeData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetSpeakerVolumeData, _data_);
}


static void dbus_service_device_real_get_speaker_volume (FreeSmartphoneGSMDevice* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetSpeakerVolumeData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetSpeakerVolumeData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_speaker_volume);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_speaker_volume_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_speaker_volume_co (_data_);
}


static gint dbus_service_device_real_get_speaker_volume_finish (FreeSmartphoneGSMDevice* base, GAsyncResult* _res_, GError** error) {
	gint result;
	DbusServiceDeviceGetSpeakerVolumeData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return 0;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_get_speaker_volume_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetSpeakerVolumeData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_speaker_volume_co (_data_);
}


static gboolean dbus_service_device_real_get_speaker_volume_co (DbusServiceDeviceGetSpeakerVolumeData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEVICE_GET_SPEAKER_VOLUME, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDeviceGetSpeakerVolume*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_device_get_speaker_volume_run (_data_->_tmp2_, dbus_service_device_get_speaker_volume_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_device_get_speaker_volume_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_device_get_speaker_volume_get_volume (_data_->_tmp3_);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->result = _data_->_tmp5_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_set_functionality_data_free (gpointer _data) {
	DbusServiceDeviceSetFunctionalityData* _data_;
	_data_ = _data;
	_g_free0 (_data_->level);
	_g_free0 (_data_->pin);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSetFunctionalityData, _data_);
}


static void dbus_service_device_real_set_functionality (FreeSmartphoneGSMDevice* base, const gchar* level, gboolean autoregister, const gchar* pin, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSetFunctionalityData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	gboolean _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSetFunctionalityData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_set_functionality);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_set_functionality_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = level;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->level = _tmp2_;
	_tmp3_ = autoregister;
	_data_->autoregister = _tmp3_;
	_tmp4_ = pin;
	_tmp5_ = g_strdup (_tmp4_);
	_data_->pin = _tmp5_;
	dbus_service_device_real_set_functionality_co (_data_);
}


static void dbus_service_device_real_set_functionality_finish (FreeSmartphoneGSMDevice* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSetFunctionalityData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_set_functionality_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSetFunctionalityData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_set_functionality_co (_data_);
}


static gboolean dbus_service_device_real_set_functionality_co (DbusServiceDeviceSetFunctionalityData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = _data_->level;
	_data_->_tmp2_ = _data_->autoregister;
	_data_->_tmp3_ = _data_->pin;
	_data_->_state_ = 1;
	fso_gsm_modem_setFunctionality (_data_->_tmp0_, _data_->_tmp1_, _data_->_tmp2_, _data_->_tmp3_, dbus_service_device_set_functionality_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_modem_setFunctionality_finish (_data_->_tmp0_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_set_microphone_muted_data_free (gpointer _data) {
	DbusServiceDeviceSetMicrophoneMutedData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSetMicrophoneMutedData, _data_);
}


static void dbus_service_device_real_set_microphone_muted (FreeSmartphoneGSMDevice* base, gboolean muted, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSetMicrophoneMutedData* _data_;
	DBusServiceDevice* _tmp0_;
	gboolean _tmp1_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSetMicrophoneMutedData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_set_microphone_muted);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_set_microphone_muted_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = muted;
	_data_->muted = _tmp1_;
	dbus_service_device_real_set_microphone_muted_co (_data_);
}


static void dbus_service_device_real_set_microphone_muted_finish (FreeSmartphoneGSMDevice* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSetMicrophoneMutedData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_set_microphone_muted_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSetMicrophoneMutedData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_set_microphone_muted_co (_data_);
}


static gboolean dbus_service_device_real_set_microphone_muted_co (DbusServiceDeviceSetMicrophoneMutedData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEVICE_SET_MICROPHONE_MUTED, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDeviceSetMicrophoneMuted*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->muted;
	_data_->_state_ = 1;
	fso_gsm_device_set_microphone_muted_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_set_microphone_muted_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_device_set_microphone_muted_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_set_speaker_volume_data_free (gpointer _data) {
	DbusServiceDeviceSetSpeakerVolumeData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSetSpeakerVolumeData, _data_);
}


static void dbus_service_device_real_set_speaker_volume (FreeSmartphoneGSMDevice* base, gint volume, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSetSpeakerVolumeData* _data_;
	DBusServiceDevice* _tmp0_;
	gint _tmp1_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSetSpeakerVolumeData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_set_speaker_volume);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_set_speaker_volume_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = volume;
	_data_->volume = _tmp1_;
	dbus_service_device_real_set_speaker_volume_co (_data_);
}


static void dbus_service_device_real_set_speaker_volume_finish (FreeSmartphoneGSMDevice* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSetSpeakerVolumeData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_set_speaker_volume_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSetSpeakerVolumeData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_set_speaker_volume_co (_data_);
}


static gboolean dbus_service_device_real_set_speaker_volume_co (DbusServiceDeviceSetSpeakerVolumeData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_DEVICE_SET_SPEAKER_VOLUME, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmDeviceSetSpeakerVolume*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->volume;
	_data_->_state_ = 1;
	fso_gsm_device_set_speaker_volume_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_set_speaker_volume_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_device_set_speaker_volume_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_device_status_data_free (gpointer _data) {
	DbusServiceDeviceGetDeviceStatusData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetDeviceStatusData, _data_);
}


static void dbus_service_device_real_get_device_status (FreeSmartphoneGSMDevice* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetDeviceStatusData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetDeviceStatusData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_device_status);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_device_status_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_device_status_co (_data_);
}


static FreeSmartphoneGSMDeviceStatus dbus_service_device_real_get_device_status_finish (FreeSmartphoneGSMDevice* base, GAsyncResult* _res_, GError** error) {
	FreeSmartphoneGSMDeviceStatus result;
	DbusServiceDeviceGetDeviceStatusData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return 0;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static gboolean dbus_service_device_real_get_device_status_co (DbusServiceDeviceGetDeviceStatusData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = 0;
	_data_->_tmp1_ = fso_gsm_modem_externalStatus (_data_->_tmp0_);
	_data_->result = _data_->_tmp1_;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_change_auth_code_data_free (gpointer _data) {
	DbusServiceDeviceChangeAuthCodeData* _data_;
	_data_ = _data;
	_g_free0 (_data_->old_pin);
	_g_free0 (_data_->new_pin);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceChangeAuthCodeData, _data_);
}


static void dbus_service_device_real_change_auth_code (FreeSmartphoneGSMSIM* base, const gchar* old_pin, const gchar* new_pin, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceChangeAuthCodeData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceChangeAuthCodeData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_change_auth_code);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_change_auth_code_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = old_pin;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->old_pin = _tmp2_;
	_tmp3_ = new_pin;
	_tmp4_ = g_strdup (_tmp3_);
	_data_->new_pin = _tmp4_;
	dbus_service_device_real_change_auth_code_co (_data_);
}


static void dbus_service_device_real_change_auth_code_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceChangeAuthCodeData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_change_auth_code_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceChangeAuthCodeData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_change_auth_code_co (_data_);
}


static gboolean dbus_service_device_real_change_auth_code_co (DbusServiceDeviceChangeAuthCodeData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_CHANGE_AUTH_CODE, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimChangeAuthCode*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->old_pin;
	_data_->_tmp4_ = _data_->new_pin;
	_data_->_state_ = 1;
	fso_gsm_sim_change_auth_code_run (_data_->_tmp2_, _data_->_tmp3_, _data_->_tmp4_, dbus_service_device_change_auth_code_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_change_auth_code_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_delete_entry_data_free (gpointer _data) {
	DbusServiceDeviceDeleteEntryData* _data_;
	_data_ = _data;
	_g_free0 (_data_->category);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceDeleteEntryData, _data_);
}


static void dbus_service_device_real_delete_entry (FreeSmartphoneGSMSIM* base, const gchar* category, gint index, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceDeleteEntryData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	gint _tmp3_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceDeleteEntryData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_delete_entry);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_delete_entry_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = category;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->category = _tmp2_;
	_tmp3_ = index;
	_data_->index = _tmp3_;
	dbus_service_device_real_delete_entry_co (_data_);
}


static void dbus_service_device_real_delete_entry_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceDeleteEntryData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_delete_entry_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceDeleteEntryData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_delete_entry_co (_data_);
}


static gboolean dbus_service_device_real_delete_entry_co (DbusServiceDeviceDeleteEntryData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_DELETE_ENTRY, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimDeleteEntry*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->category;
	_data_->_tmp4_ = _data_->index;
	_data_->_state_ = 1;
	fso_gsm_sim_delete_entry_run (_data_->_tmp2_, _data_->_tmp3_, _data_->_tmp4_, dbus_service_device_delete_entry_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_delete_entry_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_delete_message_data_free (gpointer _data) {
	DbusServiceDeviceDeleteMessageData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceDeleteMessageData, _data_);
}


static void dbus_service_device_real_delete_message (FreeSmartphoneGSMSIM* base, gint index, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceDeleteMessageData* _data_;
	DBusServiceDevice* _tmp0_;
	gint _tmp1_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceDeleteMessageData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_delete_message);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_delete_message_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = index;
	_data_->index = _tmp1_;
	dbus_service_device_real_delete_message_co (_data_);
}


static void dbus_service_device_real_delete_message_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceDeleteMessageData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_delete_message_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceDeleteMessageData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_delete_message_co (_data_);
}


static gboolean dbus_service_device_real_delete_message_co (DbusServiceDeviceDeleteMessageData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_DELETE_MESSAGE, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimDeleteMessage*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->index;
	_data_->_state_ = 1;
	fso_gsm_sim_delete_message_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_delete_message_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_delete_message_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_auth_code_required_data_free (gpointer _data) {
	DbusServiceDeviceGetAuthCodeRequiredData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetAuthCodeRequiredData, _data_);
}


static void dbus_service_device_real_get_auth_code_required (FreeSmartphoneGSMSIM* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetAuthCodeRequiredData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetAuthCodeRequiredData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_auth_code_required);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_auth_code_required_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_auth_code_required_co (_data_);
}


static gboolean dbus_service_device_real_get_auth_code_required_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	gboolean result;
	DbusServiceDeviceGetAuthCodeRequiredData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return FALSE;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_get_auth_code_required_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetAuthCodeRequiredData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_auth_code_required_co (_data_);
}


static gboolean dbus_service_device_real_get_auth_code_required_co (DbusServiceDeviceGetAuthCodeRequiredData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_GET_AUTH_CODE_REQUIRED, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimGetAuthCodeRequired*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_sim_get_auth_code_required_run (_data_->_tmp2_, dbus_service_device_get_auth_code_required_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_get_auth_code_required_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = _data_->_tmp3_->required;
	_data_->result = _data_->_tmp4_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_auth_status_data_free (gpointer _data) {
	DbusServiceDeviceGetAuthStatusData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetAuthStatusData, _data_);
}


static void dbus_service_device_real_get_auth_status (FreeSmartphoneGSMSIM* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetAuthStatusData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetAuthStatusData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_auth_status);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_auth_status_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_auth_status_co (_data_);
}


static FreeSmartphoneGSMSIMAuthStatus dbus_service_device_real_get_auth_status_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	FreeSmartphoneGSMSIMAuthStatus result;
	DbusServiceDeviceGetAuthStatusData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return 0;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_get_auth_status_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetAuthStatusData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_auth_status_co (_data_);
}


static gboolean dbus_service_device_real_get_auth_status_co (DbusServiceDeviceGetAuthStatusData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_GET_AUTH_STATUS, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimGetAuthStatus*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_sim_get_auth_status_run (_data_->_tmp2_, dbus_service_device_get_auth_status_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_get_auth_status_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = _data_->_tmp3_->status;
	_data_->result = _data_->_tmp4_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void _vala_FreeSmartphoneGSMSIMHomeZone_array_free (FreeSmartphoneGSMSIMHomeZone* array, gint array_length) {
	if (array != NULL) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			free_smartphone_gsm_sim_home_zone_destroy (&array[i]);
		}
	}
	g_free (array);
}


static void dbus_service_device_real_get_home_zone_parameters_data_free (gpointer _data) {
	DbusServiceDeviceGetHomeZoneParametersData* _data_;
	_data_ = _data;
	_data_->result = (_vala_FreeSmartphoneGSMSIMHomeZone_array_free (_data_->result, _data_->result_length1), NULL);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetHomeZoneParametersData, _data_);
}


static void dbus_service_device_real_get_home_zone_parameters (FreeSmartphoneGSMSIM* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetHomeZoneParametersData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetHomeZoneParametersData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_home_zone_parameters);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_home_zone_parameters_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_home_zone_parameters_co (_data_);
}


static FreeSmartphoneGSMSIMHomeZone* dbus_service_device_real_get_home_zone_parameters_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, int* result_length1, GError** error) {
	FreeSmartphoneGSMSIMHomeZone* result;
	DbusServiceDeviceGetHomeZoneParametersData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	*result_length1 = _data_->result_length1;
	_data_->result = NULL;
	return result;
}


static gboolean dbus_service_device_real_get_home_zone_parameters_co (DbusServiceDeviceGetHomeZoneParametersData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_phonebook_info_data_free (gpointer _data) {
	DbusServiceDeviceGetPhonebookInfoData* _data_;
	_data_ = _data;
	_g_free0 (_data_->category);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetPhonebookInfoData, _data_);
}


static void dbus_service_device_real_get_phonebook_info (FreeSmartphoneGSMSIM* base, const gchar* category, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetPhonebookInfoData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetPhonebookInfoData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_phonebook_info);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_phonebook_info_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = category;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->category = _tmp2_;
	dbus_service_device_real_get_phonebook_info_co (_data_);
}


static void dbus_service_device_real_get_phonebook_info_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, gint* slots, gint* numberlength, gint* namelength, GError** error) {
	DbusServiceDeviceGetPhonebookInfoData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	if (slots) {
		*slots = _data_->slots;
	}
	if (numberlength) {
		*numberlength = _data_->numberlength;
	}
	if (namelength) {
		*namelength = _data_->namelength;
	}
}


static void dbus_service_device_get_phonebook_info_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetPhonebookInfoData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_phonebook_info_co (_data_);
}


static gboolean dbus_service_device_real_get_phonebook_info_co (DbusServiceDeviceGetPhonebookInfoData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_GET_PHONEBOOK_INFO, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimGetPhonebookInfo*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->category;
	_data_->_tmp4_ = 0;
	_data_->_tmp5_ = 0;
	_data_->_tmp6_ = 0;
	_data_->_state_ = 1;
	fso_gsm_sim_get_phonebook_info_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_get_phonebook_info_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_get_phonebook_info_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_tmp4_, &_data_->_tmp5_, &_data_->_tmp6_, &_data_->_inner_error_);
	_data_->slots = _data_->_tmp4_;
	_data_->numberlength = _data_->_tmp5_;
	_data_->namelength = _data_->_tmp6_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_service_center_number_data_free (gpointer _data) {
	DbusServiceDeviceGetServiceCenterNumberData* _data_;
	_data_ = _data;
	_g_free0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetServiceCenterNumberData, _data_);
}


static void dbus_service_device_real_get_service_center_number (FreeSmartphoneGSMSIM* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetServiceCenterNumberData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetServiceCenterNumberData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_service_center_number);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_service_center_number_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_service_center_number_co (_data_);
}


static gchar* dbus_service_device_real_get_service_center_number_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	gchar* result;
	DbusServiceDeviceGetServiceCenterNumberData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_get_service_center_number_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetServiceCenterNumberData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_service_center_number_co (_data_);
}


static gboolean dbus_service_device_real_get_service_center_number_co (DbusServiceDeviceGetServiceCenterNumberData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_GET_SERVICE_CENTER_NUMBER, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimGetServiceCenterNumber*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_sim_get_service_center_number_run (_data_->_tmp2_, dbus_service_device_get_service_center_number_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_get_service_center_number_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = _data_->_tmp3_->number;
	_data_->_tmp5_ = g_strdup (_data_->_tmp4_);
	_data_->result = _data_->_tmp5_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_sim_info_data_free (gpointer _data) {
	DbusServiceDeviceGetSimInfoData* _data_;
	_data_ = _data;
	_g_hash_table_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetSimInfoData, _data_);
}


static void dbus_service_device_real_get_sim_info (FreeSmartphoneGSMSIM* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetSimInfoData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetSimInfoData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_sim_info);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_sim_info_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_sim_info_co (_data_);
}


static GHashTable* dbus_service_device_real_get_sim_info_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	GHashTable* result;
	DbusServiceDeviceGetSimInfoData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_get_sim_info_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetSimInfoData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_sim_info_co (_data_);
}


static gboolean dbus_service_device_real_get_sim_info_co (DbusServiceDeviceGetSimInfoData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_LOCKED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_GET_INFORMATION, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimGetInformation*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_sim_get_information_run (_data_->_tmp2_, dbus_service_device_get_sim_info_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_get_information_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_sim_get_information_get_info (_data_->_tmp3_);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->_tmp6_ = _g_hash_table_ref0 (_data_->_tmp5_);
	_data_->result = _data_->_tmp6_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_unlock_counters_data_free (gpointer _data) {
	DbusServiceDeviceGetUnlockCountersData* _data_;
	_data_ = _data;
	_g_hash_table_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetUnlockCountersData, _data_);
}


static void dbus_service_device_real_get_unlock_counters (FreeSmartphoneGSMSIM* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetUnlockCountersData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetUnlockCountersData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_unlock_counters);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_unlock_counters_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_unlock_counters_co (_data_);
}


static GHashTable* dbus_service_device_real_get_unlock_counters_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	GHashTable* result;
	DbusServiceDeviceGetUnlockCountersData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_get_unlock_counters_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetUnlockCountersData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_unlock_counters_co (_data_);
}


static gboolean dbus_service_device_real_get_unlock_counters_co (DbusServiceDeviceGetUnlockCountersData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_LOCKED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_GET_UNLOCK_COUNTERS, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimGetUnlockCounters*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_sim_get_unlock_counters_run (_data_->_tmp2_, dbus_service_device_get_unlock_counters_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_get_unlock_counters_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_sim_get_unlock_counters_get_counters (_data_->_tmp3_);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->_tmp6_ = _g_hash_table_ref0 (_data_->_tmp5_);
	_data_->result = _data_->_tmp6_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_retrieve_message_data_free (gpointer _data) {
	DbusServiceDeviceRetrieveMessageData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceRetrieveMessageData, _data_);
}


static void dbus_service_device_real_retrieve_message (FreeSmartphoneGSMSIM* base, gint index, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceRetrieveMessageData* _data_;
	DBusServiceDevice* _tmp0_;
	gint _tmp1_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceRetrieveMessageData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_retrieve_message);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_retrieve_message_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = index;
	_data_->index = _tmp1_;
	dbus_service_device_real_retrieve_message_co (_data_);
}


static void dbus_service_device_real_retrieve_message_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, gchar** status, gchar** number, gchar** contents, GHashTable** properties, GError** error) {
	DbusServiceDeviceRetrieveMessageData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	if (status) {
		*status = _data_->status;
	} else {
		_g_free0 (_data_->status);
	}
	_data_->status = NULL;
	if (number) {
		*number = _data_->number;
	} else {
		_g_free0 (_data_->number);
	}
	_data_->number = NULL;
	if (contents) {
		*contents = _data_->contents;
	} else {
		_g_free0 (_data_->contents);
	}
	_data_->contents = NULL;
	if (properties) {
		*properties = _data_->properties;
	} else {
		_g_hash_table_unref0 (_data_->properties);
	}
	_data_->properties = NULL;
}


static void dbus_service_device_retrieve_message_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceRetrieveMessageData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_retrieve_message_co (_data_);
}


static gboolean dbus_service_device_real_retrieve_message_co (DbusServiceDeviceRetrieveMessageData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_RETRIEVE_MESSAGE, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimRetrieveMessage*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->index;
	_data_->_tmp4_ = NULL;
	_data_->_tmp5_ = NULL;
	_data_->_tmp6_ = NULL;
	_data_->_tmp7_ = NULL;
	_data_->_state_ = 1;
	fso_gsm_sim_retrieve_message_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_retrieve_message_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_retrieve_message_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_tmp4_, &_data_->_tmp5_, &_data_->_tmp6_, &_data_->_tmp7_, &_data_->_inner_error_);
	_g_free0 (_data_->status);
	_data_->status = _data_->_tmp4_;
	_g_free0 (_data_->number);
	_data_->number = _data_->_tmp5_;
	_g_free0 (_data_->contents);
	_data_->contents = _data_->_tmp6_;
	_g_hash_table_unref0 (_data_->properties);
	_data_->properties = _data_->_tmp7_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void _vala_FreeSmartphoneGSMSIMEntry_array_free (FreeSmartphoneGSMSIMEntry* array, gint array_length) {
	if (array != NULL) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			free_smartphone_gsm_sim_entry_destroy (&array[i]);
		}
	}
	g_free (array);
}


static void dbus_service_device_real_retrieve_phonebook_data_free (gpointer _data) {
	DbusServiceDeviceRetrievePhonebookData* _data_;
	_data_ = _data;
	_g_free0 (_data_->category);
	_data_->result = (_vala_FreeSmartphoneGSMSIMEntry_array_free (_data_->result, _data_->result_length1), NULL);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceRetrievePhonebookData, _data_);
}


static void dbus_service_device_real_retrieve_phonebook (FreeSmartphoneGSMSIM* base, const gchar* category, gint mindex, gint maxdex, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceRetrievePhonebookData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	gint _tmp3_;
	gint _tmp4_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceRetrievePhonebookData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_retrieve_phonebook);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_retrieve_phonebook_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = category;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->category = _tmp2_;
	_tmp3_ = mindex;
	_data_->mindex = _tmp3_;
	_tmp4_ = maxdex;
	_data_->maxdex = _tmp4_;
	dbus_service_device_real_retrieve_phonebook_co (_data_);
}


static FreeSmartphoneGSMSIMEntry* dbus_service_device_real_retrieve_phonebook_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, int* result_length1, GError** error) {
	FreeSmartphoneGSMSIMEntry* result;
	DbusServiceDeviceRetrievePhonebookData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	*result_length1 = _data_->result_length1;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_retrieve_phonebook_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceRetrievePhonebookData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_retrieve_phonebook_co (_data_);
}


static FreeSmartphoneGSMSIMEntry* _vala_array_dup1 (FreeSmartphoneGSMSIMEntry* self, int length) {
	FreeSmartphoneGSMSIMEntry* result;
	int i;
	result = g_new0 (FreeSmartphoneGSMSIMEntry, length);
	for (i = 0; i < length; i++) {
		FreeSmartphoneGSMSIMEntry _tmp0_ = {0};
		free_smartphone_gsm_sim_entry_copy (&self[i], &_tmp0_);
		result[i] = _tmp0_;
	}
	return result;
}


static gboolean dbus_service_device_real_retrieve_phonebook_co (DbusServiceDeviceRetrievePhonebookData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_RETRIEVE_PHONEBOOK, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimRetrievePhonebook*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->category;
	_data_->_tmp4_ = _data_->mindex;
	_data_->_tmp5_ = _data_->maxdex;
	_data_->_state_ = 1;
	fso_gsm_sim_retrieve_phonebook_run (_data_->_tmp2_, _data_->_tmp3_, _data_->_tmp4_, _data_->_tmp5_, dbus_service_device_retrieve_phonebook_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_retrieve_phonebook_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp6_ = _data_->m;
	_data_->_tmp7_ = fso_gsm_sim_retrieve_phonebook_get_phonebook (_data_->_tmp6_, &_data_->_tmp7__length1);
	_data_->_tmp8_ = _data_->_tmp7_;
	_data_->_tmp8__length1 = _data_->_tmp7__length1;
	_data_->_tmp9_ = (_data_->_tmp8_ != NULL) ? _vala_array_dup1 (_data_->_tmp8_, _data_->_tmp8__length1) : ((gpointer) _data_->_tmp8_);
	_data_->_tmp9__length1 = _data_->_tmp8__length1;
	_data_->_tmp10_ = _data_->_tmp9_;
	_data_->_tmp10__length1 = _data_->_tmp9__length1;
	_data_->result_length1 = _data_->_tmp10__length1;
	_data_->result = _data_->_tmp10_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_send_auth_code_data_free (gpointer _data) {
	DbusServiceDeviceSendAuthCodeData* _data_;
	_data_ = _data;
	_g_free0 (_data_->pin);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSendAuthCodeData, _data_);
}


static void dbus_service_device_real_send_auth_code (FreeSmartphoneGSMSIM* base, const gchar* pin, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSendAuthCodeData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSendAuthCodeData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_send_auth_code);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_send_auth_code_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = pin;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->pin = _tmp2_;
	dbus_service_device_real_send_auth_code_co (_data_);
}


static void dbus_service_device_real_send_auth_code_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSendAuthCodeData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_send_auth_code_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSendAuthCodeData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_send_auth_code_co (_data_);
}


static gboolean dbus_service_device_real_send_auth_code_co (DbusServiceDeviceSendAuthCodeData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_LOCKED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_SEND_AUTH_CODE, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimSendAuthCode*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->pin;
	_data_->_state_ = 1;
	fso_gsm_sim_send_auth_code_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_send_auth_code_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_send_auth_code_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_send_generic_sim_command_data_free (gpointer _data) {
	DbusServiceDeviceSendGenericSimCommandData* _data_;
	_data_ = _data;
	_g_free0 (_data_->command);
	_g_free0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSendGenericSimCommandData, _data_);
}


static void dbus_service_device_real_send_generic_sim_command (FreeSmartphoneGSMSIM* base, const gchar* command, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSendGenericSimCommandData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSendGenericSimCommandData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_send_generic_sim_command);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_send_generic_sim_command_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = command;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->command = _tmp2_;
	dbus_service_device_real_send_generic_sim_command_co (_data_);
}


static gchar* dbus_service_device_real_send_generic_sim_command_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	gchar* result;
	DbusServiceDeviceSendGenericSimCommandData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static gboolean dbus_service_device_real_send_generic_sim_command_co (DbusServiceDeviceSendGenericSimCommandData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_send_restricted_sim_command_data_free (gpointer _data) {
	DbusServiceDeviceSendRestrictedSimCommandData* _data_;
	_data_ = _data;
	_g_free0 (_data_->data);
	_g_free0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSendRestrictedSimCommandData, _data_);
}


static void dbus_service_device_real_send_restricted_sim_command (FreeSmartphoneGSMSIM* base, gint command, gint fileid, gint p1, gint p2, gint p3, const gchar* data, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSendRestrictedSimCommandData* _data_;
	DBusServiceDevice* _tmp0_;
	gint _tmp1_;
	gint _tmp2_;
	gint _tmp3_;
	gint _tmp4_;
	gint _tmp5_;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSendRestrictedSimCommandData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_send_restricted_sim_command);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_send_restricted_sim_command_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = command;
	_data_->command = _tmp1_;
	_tmp2_ = fileid;
	_data_->fileid = _tmp2_;
	_tmp3_ = p1;
	_data_->p1 = _tmp3_;
	_tmp4_ = p2;
	_data_->p2 = _tmp4_;
	_tmp5_ = p3;
	_data_->p3 = _tmp5_;
	_tmp6_ = data;
	_tmp7_ = g_strdup (_tmp6_);
	_data_->data = _tmp7_;
	dbus_service_device_real_send_restricted_sim_command_co (_data_);
}


static gchar* dbus_service_device_real_send_restricted_sim_command_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	gchar* result;
	DbusServiceDeviceSendRestrictedSimCommandData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static gboolean dbus_service_device_real_send_restricted_sim_command_co (DbusServiceDeviceSendRestrictedSimCommandData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_send_stored_message_data_free (gpointer _data) {
	DbusServiceDeviceSendStoredMessageData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSendStoredMessageData, _data_);
}


static void dbus_service_device_real_send_stored_message (FreeSmartphoneGSMSIM* base, gint index, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSendStoredMessageData* _data_;
	DBusServiceDevice* _tmp0_;
	gint _tmp1_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSendStoredMessageData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_send_stored_message);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_send_stored_message_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = index;
	_data_->index = _tmp1_;
	dbus_service_device_real_send_stored_message_co (_data_);
}


static void dbus_service_device_real_send_stored_message_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, gint* transaction_index, gchar** timestamp, GError** error) {
	DbusServiceDeviceSendStoredMessageData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	if (transaction_index) {
		*transaction_index = _data_->transaction_index;
	}
	if (timestamp) {
		*timestamp = _data_->timestamp;
	} else {
		_g_free0 (_data_->timestamp);
	}
	_data_->timestamp = NULL;
}


static void dbus_service_device_send_stored_message_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSendStoredMessageData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_send_stored_message_co (_data_);
}


static gboolean dbus_service_device_real_send_stored_message_co (DbusServiceDeviceSendStoredMessageData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_SEND_STORED_MESSAGE, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimSendStoredMessage*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->index;
	_data_->_state_ = 1;
	fso_gsm_sim_send_stored_message_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_send_stored_message_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_send_stored_message_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp4_ = _data_->m;
	_data_->_tmp5_ = fso_gsm_sim_send_stored_message_get_transaction_index (_data_->_tmp4_);
	_data_->_tmp6_ = _data_->_tmp5_;
	_data_->transaction_index = _data_->_tmp6_;
	_data_->_tmp7_ = _data_->m;
	_data_->_tmp8_ = fso_gsm_sim_send_stored_message_get_timestamp (_data_->_tmp7_);
	_data_->_tmp9_ = _data_->_tmp8_;
	_data_->_tmp10_ = g_strdup (_data_->_tmp9_);
	_g_free0 (_data_->timestamp);
	_data_->timestamp = _data_->_tmp10_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_set_auth_code_required_data_free (gpointer _data) {
	DbusServiceDeviceSetAuthCodeRequiredData* _data_;
	_data_ = _data;
	_g_free0 (_data_->pin);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSetAuthCodeRequiredData, _data_);
}


static void dbus_service_device_real_set_auth_code_required (FreeSmartphoneGSMSIM* base, gboolean check, const gchar* pin, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSetAuthCodeRequiredData* _data_;
	DBusServiceDevice* _tmp0_;
	gboolean _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSetAuthCodeRequiredData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_set_auth_code_required);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_set_auth_code_required_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = check;
	_data_->check = _tmp1_;
	_tmp2_ = pin;
	_tmp3_ = g_strdup (_tmp2_);
	_data_->pin = _tmp3_;
	dbus_service_device_real_set_auth_code_required_co (_data_);
}


static void dbus_service_device_real_set_auth_code_required_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSetAuthCodeRequiredData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_set_auth_code_required_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSetAuthCodeRequiredData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_set_auth_code_required_co (_data_);
}


static gboolean dbus_service_device_real_set_auth_code_required_co (DbusServiceDeviceSetAuthCodeRequiredData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_SET_AUTH_CODE_REQUIRED, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimSetAuthCodeRequired*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->check;
	_data_->_tmp4_ = _data_->pin;
	_data_->_state_ = 1;
	fso_gsm_sim_set_auth_code_required_run (_data_->_tmp2_, _data_->_tmp3_, _data_->_tmp4_, dbus_service_device_set_auth_code_required_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_set_auth_code_required_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_set_service_center_number_data_free (gpointer _data) {
	DbusServiceDeviceSetServiceCenterNumberData* _data_;
	_data_ = _data;
	_g_free0 (_data_->number);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSetServiceCenterNumberData, _data_);
}


static void dbus_service_device_real_set_service_center_number (FreeSmartphoneGSMSIM* base, const gchar* number, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSetServiceCenterNumberData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSetServiceCenterNumberData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_set_service_center_number);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_set_service_center_number_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = number;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->number = _tmp2_;
	dbus_service_device_real_set_service_center_number_co (_data_);
}


static void dbus_service_device_real_set_service_center_number_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSetServiceCenterNumberData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_set_service_center_number_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSetServiceCenterNumberData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_set_service_center_number_co (_data_);
}


static gboolean dbus_service_device_real_set_service_center_number_co (DbusServiceDeviceSetServiceCenterNumberData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_SET_SERVICE_CENTER_NUMBER, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimSetServiceCenterNumber*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->number;
	_data_->_state_ = 1;
	fso_gsm_sim_set_service_center_number_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_set_service_center_number_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_set_service_center_number_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_store_entry_data_free (gpointer _data) {
	DbusServiceDeviceStoreEntryData* _data_;
	_data_ = _data;
	_g_free0 (_data_->category);
	_g_free0 (_data_->name);
	_g_free0 (_data_->number);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceStoreEntryData, _data_);
}


static void dbus_service_device_real_store_entry (FreeSmartphoneGSMSIM* base, const gchar* category, gint index, const gchar* name, const gchar* number, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceStoreEntryData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	gint _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceStoreEntryData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_store_entry);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_store_entry_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = category;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->category = _tmp2_;
	_tmp3_ = index;
	_data_->index = _tmp3_;
	_tmp4_ = name;
	_tmp5_ = g_strdup (_tmp4_);
	_data_->name = _tmp5_;
	_tmp6_ = number;
	_tmp7_ = g_strdup (_tmp6_);
	_data_->number = _tmp7_;
	dbus_service_device_real_store_entry_co (_data_);
}


static void dbus_service_device_real_store_entry_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceStoreEntryData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_store_entry_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceStoreEntryData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_store_entry_co (_data_);
}


static gboolean dbus_service_device_real_store_entry_co (DbusServiceDeviceStoreEntryData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_WRITE_ENTRY, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimWriteEntry*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->category;
	_data_->_tmp4_ = _data_->index;
	_data_->_tmp5_ = _data_->number;
	_data_->_tmp6_ = _data_->name;
	_data_->_state_ = 1;
	fso_gsm_sim_write_entry_run (_data_->_tmp2_, _data_->_tmp3_, _data_->_tmp4_, _data_->_tmp5_, _data_->_tmp6_, dbus_service_device_store_entry_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_write_entry_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_store_message_data_free (gpointer _data) {
	DbusServiceDeviceStoreMessageData* _data_;
	_data_ = _data;
	_g_free0 (_data_->recipient_number);
	_g_free0 (_data_->contents);
	_g_hash_table_unref0 (_data_->properties);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceStoreMessageData, _data_);
}


static void dbus_service_device_real_store_message (FreeSmartphoneGSMSIM* base, const gchar* recipient_number, const gchar* contents, GHashTable* properties, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceStoreMessageData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	GHashTable* _tmp5_;
	GHashTable* _tmp6_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceStoreMessageData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_store_message);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_store_message_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = recipient_number;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->recipient_number = _tmp2_;
	_tmp3_ = contents;
	_tmp4_ = g_strdup (_tmp3_);
	_data_->contents = _tmp4_;
	_tmp5_ = properties;
	_tmp6_ = _g_hash_table_ref0 (_tmp5_);
	_data_->properties = _tmp6_;
	dbus_service_device_real_store_message_co (_data_);
}


static gint dbus_service_device_real_store_message_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	gint result;
	DbusServiceDeviceStoreMessageData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return 0;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_store_message_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceStoreMessageData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_store_message_co (_data_);
}


static gboolean dbus_service_device_real_store_message_co (DbusServiceDeviceStoreMessageData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_STORE_MESSAGE, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimStoreMessage*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->recipient_number;
	_data_->_tmp4_ = _data_->contents;
	_data_->_state_ = 1;
	fso_gsm_sim_store_message_run (_data_->_tmp2_, _data_->_tmp3_, _data_->_tmp4_, FALSE, dbus_service_device_store_message_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_store_message_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp5_ = _data_->m;
	_data_->_tmp6_ = fso_gsm_sim_store_message_get_memory_index (_data_->_tmp5_);
	_data_->_tmp7_ = _data_->_tmp6_;
	_data_->result = _data_->_tmp7_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_unlock_data_free (gpointer _data) {
	DbusServiceDeviceUnlockData* _data_;
	_data_ = _data;
	_g_free0 (_data_->puk);
	_g_free0 (_data_->new_pin);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceUnlockData, _data_);
}


static void dbus_service_device_real_unlock (FreeSmartphoneGSMSIM* base, const gchar* puk, const gchar* new_pin, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceUnlockData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceUnlockData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_unlock);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_unlock_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = puk;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->puk = _tmp2_;
	_tmp3_ = new_pin;
	_tmp4_ = g_strdup (_tmp3_);
	_data_->new_pin = _tmp4_;
	dbus_service_device_real_unlock_co (_data_);
}


static void dbus_service_device_real_unlock_finish (FreeSmartphoneGSMSIM* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceUnlockData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_unlock_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceUnlockData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_unlock_co (_data_);
}


static gboolean dbus_service_device_real_unlock_co (DbusServiceDeviceUnlockData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_LOCKED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SIM_UNLOCK, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSimUnlock*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->puk;
	_data_->_tmp4_ = _data_->new_pin;
	_data_->_state_ = 1;
	fso_gsm_sim_unlock_run (_data_->_tmp2_, _data_->_tmp3_, _data_->_tmp4_, dbus_service_device_unlock_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sim_unlock_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_size_for_text_message_data_free (gpointer _data) {
	DbusServiceDeviceGetSizeForTextMessageData* _data_;
	_data_ = _data;
	_g_free0 (_data_->contents);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetSizeForTextMessageData, _data_);
}


static void dbus_service_device_real_get_size_for_text_message (FreeSmartphoneGSMSMS* base, const gchar* contents, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetSizeForTextMessageData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetSizeForTextMessageData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_size_for_text_message);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_size_for_text_message_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = contents;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->contents = _tmp2_;
	dbus_service_device_real_get_size_for_text_message_co (_data_);
}


static guint dbus_service_device_real_get_size_for_text_message_finish (FreeSmartphoneGSMSMS* base, GAsyncResult* _res_, GError** error) {
	guint result;
	DbusServiceDeviceGetSizeForTextMessageData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return 0U;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_get_size_for_text_message_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetSizeForTextMessageData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_size_for_text_message_co (_data_);
}


static gboolean dbus_service_device_real_get_size_for_text_message_co (DbusServiceDeviceGetSizeForTextMessageData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SMS_GET_SIZE_FOR_TEXT_MESSAGE, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSmsGetSizeForTextMessage*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->contents;
	_data_->_state_ = 1;
	fso_gsm_sms_get_size_for_text_message_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_get_size_for_text_message_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sms_get_size_for_text_message_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp4_ = _data_->m;
	_data_->_tmp5_ = fso_gsm_sms_get_size_for_text_message_get_size (_data_->_tmp4_);
	_data_->_tmp6_ = _data_->_tmp5_;
	_data_->result = _data_->_tmp6_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void _vala_FreeSmartphoneGSMSIMMessage_array_free (FreeSmartphoneGSMSIMMessage* array, gint array_length) {
	if (array != NULL) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			free_smartphone_gsm_sim_message_destroy (&array[i]);
		}
	}
	g_free (array);
}


static void dbus_service_device_real_retrieve_text_messages_data_free (gpointer _data) {
	DbusServiceDeviceRetrieveTextMessagesData* _data_;
	_data_ = _data;
	_data_->result = (_vala_FreeSmartphoneGSMSIMMessage_array_free (_data_->result, _data_->result_length1), NULL);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceRetrieveTextMessagesData, _data_);
}


static void dbus_service_device_real_retrieve_text_messages (FreeSmartphoneGSMSMS* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceRetrieveTextMessagesData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceRetrieveTextMessagesData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_retrieve_text_messages);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_retrieve_text_messages_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_retrieve_text_messages_co (_data_);
}


static FreeSmartphoneGSMSIMMessage* dbus_service_device_real_retrieve_text_messages_finish (FreeSmartphoneGSMSMS* base, GAsyncResult* _res_, int* result_length1, GError** error) {
	FreeSmartphoneGSMSIMMessage* result;
	DbusServiceDeviceRetrieveTextMessagesData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	*result_length1 = _data_->result_length1;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_retrieve_text_messages_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceRetrieveTextMessagesData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_retrieve_text_messages_co (_data_);
}


static FreeSmartphoneGSMSIMMessage* _vala_array_dup2 (FreeSmartphoneGSMSIMMessage* self, int length) {
	FreeSmartphoneGSMSIMMessage* result;
	int i;
	result = g_new0 (FreeSmartphoneGSMSIMMessage, length);
	for (i = 0; i < length; i++) {
		FreeSmartphoneGSMSIMMessage _tmp0_ = {0};
		free_smartphone_gsm_sim_message_copy (&self[i], &_tmp0_);
		result[i] = _tmp0_;
	}
	return result;
}


static gboolean dbus_service_device_real_retrieve_text_messages_co (DbusServiceDeviceRetrieveTextMessagesData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SMS_RETRIEVE_TEXT_MESSAGES, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSmsRetrieveTextMessages*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_sms_retrieve_text_messages_run (_data_->_tmp2_, dbus_service_device_retrieve_text_messages_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sms_retrieve_text_messages_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_sms_retrieve_text_messages_get_messagebook (_data_->_tmp3_, &_data_->_tmp4__length1);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->_tmp5__length1 = _data_->_tmp4__length1;
	_data_->_tmp6_ = (_data_->_tmp5_ != NULL) ? _vala_array_dup2 (_data_->_tmp5_, _data_->_tmp5__length1) : ((gpointer) _data_->_tmp5_);
	_data_->_tmp6__length1 = _data_->_tmp5__length1;
	_data_->_tmp7_ = _data_->_tmp6_;
	_data_->_tmp7__length1 = _data_->_tmp6__length1;
	_data_->result_length1 = _data_->_tmp7__length1;
	_data_->result = _data_->_tmp7_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_send_text_message_data_free (gpointer _data) {
	DbusServiceDeviceSendTextMessageData* _data_;
	_data_ = _data;
	_g_free0 (_data_->recipient_number);
	_g_free0 (_data_->contents);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSendTextMessageData, _data_);
}


static void dbus_service_device_real_send_text_message (FreeSmartphoneGSMSMS* base, const gchar* recipient_number, const gchar* contents, gboolean want_report, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSendTextMessageData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gboolean _tmp5_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSendTextMessageData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_send_text_message);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_send_text_message_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = recipient_number;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->recipient_number = _tmp2_;
	_tmp3_ = contents;
	_tmp4_ = g_strdup (_tmp3_);
	_data_->contents = _tmp4_;
	_tmp5_ = want_report;
	_data_->want_report = _tmp5_;
	dbus_service_device_real_send_text_message_co (_data_);
}


static void dbus_service_device_real_send_text_message_finish (FreeSmartphoneGSMSMS* base, GAsyncResult* _res_, gint* transaction_index, gchar** timestamp, GError** error) {
	DbusServiceDeviceSendTextMessageData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	if (transaction_index) {
		*transaction_index = _data_->transaction_index;
	}
	if (timestamp) {
		*timestamp = _data_->timestamp;
	} else {
		_g_free0 (_data_->timestamp);
	}
	_data_->timestamp = NULL;
}


static void dbus_service_device_send_text_message_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSendTextMessageData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_send_text_message_co (_data_);
}


static gboolean dbus_service_device_real_send_text_message_co (DbusServiceDeviceSendTextMessageData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_SMS_SEND_TEXT_MESSAGE, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmSmsSendTextMessage*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->recipient_number;
	_data_->_tmp4_ = _data_->contents;
	_data_->_tmp5_ = _data_->want_report;
	_data_->_state_ = 1;
	fso_gsm_sms_send_text_message_run (_data_->_tmp2_, _data_->_tmp3_, _data_->_tmp4_, _data_->_tmp5_, dbus_service_device_send_text_message_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_sms_send_text_message_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp6_ = _data_->m;
	_data_->_tmp7_ = fso_gsm_sms_send_text_message_get_transaction_index (_data_->_tmp6_);
	_data_->_tmp8_ = _data_->_tmp7_;
	_data_->transaction_index = _data_->_tmp8_;
	_data_->_tmp9_ = _data_->m;
	_data_->_tmp10_ = fso_gsm_sms_send_text_message_get_timestamp (_data_->_tmp9_);
	_data_->_tmp11_ = _data_->_tmp10_;
	_data_->_tmp12_ = g_strdup (_data_->_tmp11_);
	_g_free0 (_data_->timestamp);
	_data_->timestamp = _data_->_tmp12_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_disable_call_forwarding_data_free (gpointer _data) {
	DbusServiceDeviceDisableCallForwardingData* _data_;
	_data_ = _data;
	_g_free0 (_data_->reason);
	_g_free0 (_data_->class_);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceDisableCallForwardingData, _data_);
}


static void dbus_service_device_real_disable_call_forwarding (FreeSmartphoneGSMNetwork* base, const gchar* reason, const gchar* class_, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceDisableCallForwardingData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceDisableCallForwardingData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_disable_call_forwarding);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_disable_call_forwarding_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = reason;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->reason = _tmp2_;
	_tmp3_ = class_;
	_tmp4_ = g_strdup (_tmp3_);
	_data_->class_ = _tmp4_;
	dbus_service_device_real_disable_call_forwarding_co (_data_);
}


static void dbus_service_device_real_disable_call_forwarding_finish (FreeSmartphoneGSMNetwork* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceDisableCallForwardingData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static gboolean dbus_service_device_real_disable_call_forwarding_co (DbusServiceDeviceDisableCallForwardingData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_enable_call_forwarding_data_free (gpointer _data) {
	DbusServiceDeviceEnableCallForwardingData* _data_;
	_data_ = _data;
	_g_free0 (_data_->reason);
	_g_free0 (_data_->class_);
	_g_free0 (_data_->number);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceEnableCallForwardingData, _data_);
}


static void dbus_service_device_real_enable_call_forwarding (FreeSmartphoneGSMNetwork* base, const gchar* reason, const gchar* class_, const gchar* number, gint timeout, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceEnableCallForwardingData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	const gchar* _tmp5_;
	gchar* _tmp6_;
	gint _tmp7_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceEnableCallForwardingData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_enable_call_forwarding);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_enable_call_forwarding_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = reason;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->reason = _tmp2_;
	_tmp3_ = class_;
	_tmp4_ = g_strdup (_tmp3_);
	_data_->class_ = _tmp4_;
	_tmp5_ = number;
	_tmp6_ = g_strdup (_tmp5_);
	_data_->number = _tmp6_;
	_tmp7_ = timeout;
	_data_->timeout = _tmp7_;
	dbus_service_device_real_enable_call_forwarding_co (_data_);
}


static void dbus_service_device_real_enable_call_forwarding_finish (FreeSmartphoneGSMNetwork* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceEnableCallForwardingData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static gboolean dbus_service_device_real_enable_call_forwarding_co (DbusServiceDeviceEnableCallForwardingData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_call_forwarding_data_free (gpointer _data) {
	DbusServiceDeviceGetCallForwardingData* _data_;
	_data_ = _data;
	_g_free0 (_data_->reason);
	_g_hash_table_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetCallForwardingData, _data_);
}


static void dbus_service_device_real_get_call_forwarding (FreeSmartphoneGSMNetwork* base, const gchar* reason, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetCallForwardingData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetCallForwardingData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_call_forwarding);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_call_forwarding_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = reason;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->reason = _tmp2_;
	dbus_service_device_real_get_call_forwarding_co (_data_);
}


static GHashTable* dbus_service_device_real_get_call_forwarding_finish (FreeSmartphoneGSMNetwork* base, GAsyncResult* _res_, GError** error) {
	GHashTable* result;
	DbusServiceDeviceGetCallForwardingData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static gboolean dbus_service_device_real_get_call_forwarding_co (DbusServiceDeviceGetCallForwardingData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_calling_identification_data_free (gpointer _data) {
	DbusServiceDeviceGetCallingIdentificationData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetCallingIdentificationData, _data_);
}


static void dbus_service_device_real_get_calling_identification (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetCallingIdentificationData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetCallingIdentificationData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_calling_identification);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_calling_identification_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_calling_identification_co (_data_);
}


static FreeSmartphoneGSMCallingIdentificationStatus dbus_service_device_real_get_calling_identification_finish (FreeSmartphoneGSMNetwork* base, GAsyncResult* _res_, GError** error) {
	FreeSmartphoneGSMCallingIdentificationStatus result;
	DbusServiceDeviceGetCallingIdentificationData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return 0;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_get_calling_identification_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetCallingIdentificationData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_calling_identification_co (_data_);
}


static gboolean dbus_service_device_real_get_calling_identification_co (DbusServiceDeviceGetCallingIdentificationData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_NETWORK_GET_CALLING_ID, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmNetworkGetCallingId*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_network_get_calling_id_run (_data_->_tmp2_, dbus_service_device_get_calling_identification_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_network_get_calling_id_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_network_get_calling_id_get_status (_data_->_tmp3_);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->result = _data_->_tmp5_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_time_report_data_free (gpointer _data) {
	DbusServiceDeviceGetTimeReportData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetTimeReportData, _data_);
}


static void dbus_service_device_real_get_time_report (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetTimeReportData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetTimeReportData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_time_report);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_time_report_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_time_report_co (_data_);
}


static void dbus_service_device_real_get_time_report_finish (FreeSmartphoneGSMNetwork* base, GAsyncResult* _res_, gint* time, gint* timestamp, gint* zone, gint* zonestamp, GError** error) {
	DbusServiceDeviceGetTimeReportData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	if (time) {
		*time = _data_->time;
	}
	if (timestamp) {
		*timestamp = _data_->timestamp;
	}
	if (zone) {
		*zone = _data_->zone;
	}
	if (zonestamp) {
		*zonestamp = _data_->zonestamp;
	}
}


static gpointer _fso_gsm_network_time_report_ref0 (gpointer self) {
	return self ? fso_gsm_network_time_report_ref (self) : NULL;
}


static gboolean dbus_service_device_real_get_time_report_co (DbusServiceDeviceGetTimeReportData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_data (_data_->_tmp0_);
	_data_->_tmp2_ = _data_->_tmp1_;
	_data_->_tmp3_ = _data_->_tmp2_->networkTimeReport;
	_data_->_tmp4_ = _fso_gsm_network_time_report_ref0 (_data_->_tmp3_);
	_data_->_tmp5_ = _data_->_tmp4_;
	_g_object_unref0 (_data_->_tmp2_);
	_data_->ltr = _data_->_tmp5_;
	_data_->_tmp6_ = _data_->ltr;
	_data_->_tmp7_ = _data_->_tmp6_->time;
	_data_->time = _data_->_tmp7_;
	_data_->_tmp8_ = _data_->ltr;
	_data_->_tmp9_ = _data_->_tmp8_->timestamp;
	_data_->timestamp = _data_->_tmp9_;
	_data_->_tmp10_ = _data_->ltr;
	_data_->_tmp11_ = _data_->_tmp10_->zone;
	_data_->zone = _data_->_tmp11_;
	_data_->_tmp12_ = _data_->ltr;
	_data_->_tmp13_ = _data_->_tmp12_->zonestamp;
	_data_->zonestamp = _data_->_tmp13_;
	_fso_gsm_network_time_report_unref0 (_data_->ltr);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_signal_strength_data_free (gpointer _data) {
	DbusServiceDeviceGetSignalStrengthData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetSignalStrengthData, _data_);
}


static void dbus_service_device_real_get_signal_strength (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetSignalStrengthData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetSignalStrengthData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_signal_strength);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_signal_strength_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_signal_strength_co (_data_);
}


static gint dbus_service_device_real_get_signal_strength_finish (FreeSmartphoneGSMNetwork* base, GAsyncResult* _res_, GError** error) {
	gint result;
	DbusServiceDeviceGetSignalStrengthData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return 0;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_get_signal_strength_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetSignalStrengthData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_signal_strength_co (_data_);
}


static gboolean dbus_service_device_real_get_signal_strength_co (DbusServiceDeviceGetSignalStrengthData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_NETWORK_GET_SIGNAL_STRENGTH, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmNetworkGetSignalStrength*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_network_get_signal_strength_run (_data_->_tmp2_, dbus_service_device_get_signal_strength_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_network_get_signal_strength_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_network_get_signal_strength_get_signal (_data_->_tmp3_);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->result = _data_->_tmp5_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_status_data_free (gpointer _data) {
	DbusServiceDeviceGetStatusData* _data_;
	_data_ = _data;
	_g_hash_table_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetStatusData, _data_);
}


static void dbus_service_device_real_get_status (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetStatusData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetStatusData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_status);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_status_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_status_co (_data_);
}


static GHashTable* dbus_service_device_real_get_status_finish (FreeSmartphoneGSMNetwork* base, GAsyncResult* _res_, GError** error) {
	GHashTable* result;
	DbusServiceDeviceGetStatusData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_get_status_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetStatusData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_status_co (_data_);
}


static gboolean dbus_service_device_real_get_status_co (DbusServiceDeviceGetStatusData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_NETWORK_GET_STATUS, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmNetworkGetStatus*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_network_get_status_run (_data_->_tmp2_, dbus_service_device_get_status_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_network_get_status_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_network_get_status_get_status (_data_->_tmp3_);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->_tmp6_ = _g_hash_table_ref0 (_data_->_tmp5_);
	_data_->result = _data_->_tmp6_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void _vala_FreeSmartphoneGSMNetworkProvider_array_free (FreeSmartphoneGSMNetworkProvider* array, gint array_length) {
	if (array != NULL) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			free_smartphone_gsm_network_provider_destroy (&array[i]);
		}
	}
	g_free (array);
}


static void dbus_service_device_real_list_providers_data_free (gpointer _data) {
	DbusServiceDeviceListProvidersData* _data_;
	_data_ = _data;
	_data_->result = (_vala_FreeSmartphoneGSMNetworkProvider_array_free (_data_->result, _data_->result_length1), NULL);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceListProvidersData, _data_);
}


static void dbus_service_device_real_list_providers (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceListProvidersData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceListProvidersData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_list_providers);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_list_providers_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_list_providers_co (_data_);
}


static FreeSmartphoneGSMNetworkProvider* dbus_service_device_real_list_providers_finish (FreeSmartphoneGSMNetwork* base, GAsyncResult* _res_, int* result_length1, GError** error) {
	FreeSmartphoneGSMNetworkProvider* result;
	DbusServiceDeviceListProvidersData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	*result_length1 = _data_->result_length1;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_list_providers_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceListProvidersData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_list_providers_co (_data_);
}


static FreeSmartphoneGSMNetworkProvider* _vala_array_dup3 (FreeSmartphoneGSMNetworkProvider* self, int length) {
	FreeSmartphoneGSMNetworkProvider* result;
	int i;
	result = g_new0 (FreeSmartphoneGSMNetworkProvider, length);
	for (i = 0; i < length; i++) {
		FreeSmartphoneGSMNetworkProvider _tmp0_ = {0};
		free_smartphone_gsm_network_provider_copy (&self[i], &_tmp0_);
		result[i] = _tmp0_;
	}
	return result;
}


static gboolean dbus_service_device_real_list_providers_co (DbusServiceDeviceListProvidersData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_NETWORK_LIST_PROVIDERS, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmNetworkListProviders*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_network_list_providers_run (_data_->_tmp2_, dbus_service_device_list_providers_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_network_list_providers_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_network_list_providers_get_providers (_data_->_tmp3_, &_data_->_tmp4__length1);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->_tmp5__length1 = _data_->_tmp4__length1;
	_data_->_tmp6_ = (_data_->_tmp5_ != NULL) ? _vala_array_dup3 (_data_->_tmp5_, _data_->_tmp5__length1) : ((gpointer) _data_->_tmp5_);
	_data_->_tmp6__length1 = _data_->_tmp5__length1;
	_data_->_tmp7_ = _data_->_tmp6_;
	_data_->_tmp7__length1 = _data_->_tmp6__length1;
	_data_->result_length1 = _data_->_tmp7__length1;
	_data_->result = _data_->_tmp7_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_register__data_free (gpointer _data) {
	DbusServiceDeviceRegisterData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceRegisterData, _data_);
}


static void dbus_service_device_real_register_ (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceRegisterData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceRegisterData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_register_);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_register__data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_register__co (_data_);
}


static void dbus_service_device_real_register__finish (FreeSmartphoneGSMNetwork* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceRegisterData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_register__ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceRegisterData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_register__co (_data_);
}


static gboolean dbus_service_device_real_register__co (DbusServiceDeviceRegisterData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_NETWORK_REGISTER, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmNetworkRegister*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_network_register_run (_data_->_tmp2_, dbus_service_device_register__ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_network_register_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_register_with_provider_data_free (gpointer _data) {
	DbusServiceDeviceRegisterWithProviderData* _data_;
	_data_ = _data;
	_g_free0 (_data_->operator_code);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceRegisterWithProviderData, _data_);
}


static void dbus_service_device_real_register_with_provider (FreeSmartphoneGSMNetwork* base, const gchar* operator_code, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceRegisterWithProviderData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceRegisterWithProviderData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_register_with_provider);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_register_with_provider_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = operator_code;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->operator_code = _tmp2_;
	dbus_service_device_real_register_with_provider_co (_data_);
}


static void dbus_service_device_real_register_with_provider_finish (FreeSmartphoneGSMNetwork* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceRegisterWithProviderData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_register_with_provider_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceRegisterWithProviderData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_register_with_provider_co (_data_);
}


static gboolean dbus_service_device_real_register_with_provider_co (DbusServiceDeviceRegisterWithProviderData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_NETWORK_REGISTER_WITH_PROVIDER, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmNetworkRegisterWithProvider*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->operator_code;
	_data_->_state_ = 1;
	fso_gsm_network_register_with_provider_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_register_with_provider_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_network_register_with_provider_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_send_ussd_request_data_free (gpointer _data) {
	DbusServiceDeviceSendUssdRequestData* _data_;
	_data_ = _data;
	_g_free0 (_data_->request);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSendUssdRequestData, _data_);
}


static void dbus_service_device_real_send_ussd_request (FreeSmartphoneGSMNetwork* base, const gchar* request, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSendUssdRequestData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSendUssdRequestData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_send_ussd_request);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_send_ussd_request_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = request;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->request = _tmp2_;
	dbus_service_device_real_send_ussd_request_co (_data_);
}


static void dbus_service_device_real_send_ussd_request_finish (FreeSmartphoneGSMNetwork* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSendUssdRequestData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_send_ussd_request_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSendUssdRequestData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_send_ussd_request_co (_data_);
}


static gboolean dbus_service_device_real_send_ussd_request_co (DbusServiceDeviceSendUssdRequestData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_NETWORK_SEND_USSD_REQUEST, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmNetworkSendUssdRequest*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->request;
	_data_->_state_ = 1;
	fso_gsm_network_send_ussd_request_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_send_ussd_request_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_network_send_ussd_request_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_set_calling_identification_data_free (gpointer _data) {
	DbusServiceDeviceSetCallingIdentificationData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSetCallingIdentificationData, _data_);
}


static void dbus_service_device_real_set_calling_identification (FreeSmartphoneGSMNetwork* base, FreeSmartphoneGSMCallingIdentificationStatus status, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSetCallingIdentificationData* _data_;
	DBusServiceDevice* _tmp0_;
	FreeSmartphoneGSMCallingIdentificationStatus _tmp1_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSetCallingIdentificationData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_set_calling_identification);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_set_calling_identification_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = status;
	_data_->status = _tmp1_;
	dbus_service_device_real_set_calling_identification_co (_data_);
}


static void dbus_service_device_real_set_calling_identification_finish (FreeSmartphoneGSMNetwork* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSetCallingIdentificationData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_set_calling_identification_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSetCallingIdentificationData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_set_calling_identification_co (_data_);
}


static gboolean dbus_service_device_real_set_calling_identification_co (DbusServiceDeviceSetCallingIdentificationData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_NETWORK_SET_CALLING_ID, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmNetworkSetCallingId*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->status;
	_data_->_state_ = 1;
	fso_gsm_network_set_calling_id_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_set_calling_identification_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_network_set_calling_id_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_unregister_data_free (gpointer _data) {
	DbusServiceDeviceUnregisterData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceUnregisterData, _data_);
}


static void dbus_service_device_real_unregister (FreeSmartphoneGSMNetwork* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceUnregisterData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceUnregisterData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_unregister);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_unregister_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_unregister_co (_data_);
}


static void dbus_service_device_real_unregister_finish (FreeSmartphoneGSMNetwork* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceUnregisterData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_unregister_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceUnregisterData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_unregister_co (_data_);
}


static gboolean dbus_service_device_real_unregister_co (DbusServiceDeviceUnregisterData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_NETWORK_UNREGISTER, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmNetworkUnregister*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_network_unregister_run (_data_->_tmp2_, dbus_service_device_unregister_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_network_unregister_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_activate_data_free (gpointer _data) {
	DbusServiceDeviceActivateData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceActivateData, _data_);
}


static void dbus_service_device_real_activate (FreeSmartphoneGSMCall* base, gint id, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceActivateData* _data_;
	DBusServiceDevice* _tmp0_;
	gint _tmp1_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceActivateData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_activate);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_activate_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = id;
	_data_->id = _tmp1_;
	dbus_service_device_real_activate_co (_data_);
}


static void dbus_service_device_real_activate_finish (FreeSmartphoneGSMCall* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceActivateData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_activate_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceActivateData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_activate_co (_data_);
}


static gboolean dbus_service_device_real_activate_co (DbusServiceDeviceActivateData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_CALL_ACTIVATE, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmCallActivate*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->id;
	_data_->_state_ = 1;
	fso_gsm_call_activate_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_activate_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_call_activate_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_activate_conference_data_free (gpointer _data) {
	DbusServiceDeviceActivateConferenceData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceActivateConferenceData, _data_);
}


static void dbus_service_device_real_activate_conference (FreeSmartphoneGSMCall* base, gint id, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceActivateConferenceData* _data_;
	DBusServiceDevice* _tmp0_;
	gint _tmp1_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceActivateConferenceData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_activate_conference);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_activate_conference_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = id;
	_data_->id = _tmp1_;
	dbus_service_device_real_activate_conference_co (_data_);
}


static void dbus_service_device_real_activate_conference_finish (FreeSmartphoneGSMCall* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceActivateConferenceData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static gboolean dbus_service_device_real_activate_conference_co (DbusServiceDeviceActivateConferenceData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_emergency_data_free (gpointer _data) {
	DbusServiceDeviceEmergencyData* _data_;
	_data_ = _data;
	_g_free0 (_data_->number);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceEmergencyData, _data_);
}


static void dbus_service_device_real_emergency (FreeSmartphoneGSMCall* base, const gchar* number, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceEmergencyData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceEmergencyData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_emergency);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_emergency_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = number;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->number = _tmp2_;
	dbus_service_device_real_emergency_co (_data_);
}


static void dbus_service_device_real_emergency_finish (FreeSmartphoneGSMCall* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceEmergencyData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static gboolean dbus_service_device_real_emergency_co (DbusServiceDeviceEmergencyData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_hold_active_data_free (gpointer _data) {
	DbusServiceDeviceHoldActiveData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceHoldActiveData, _data_);
}


static void dbus_service_device_real_hold_active (FreeSmartphoneGSMCall* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceHoldActiveData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceHoldActiveData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_hold_active);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_hold_active_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_hold_active_co (_data_);
}


static void dbus_service_device_real_hold_active_finish (FreeSmartphoneGSMCall* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceHoldActiveData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_hold_active_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceHoldActiveData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_hold_active_co (_data_);
}


static gboolean dbus_service_device_real_hold_active_co (DbusServiceDeviceHoldActiveData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_CALL_HOLD_ACTIVE, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmCallHoldActive*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_call_hold_active_run (_data_->_tmp2_, dbus_service_device_hold_active_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_call_hold_active_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_initiate_data_free (gpointer _data) {
	DbusServiceDeviceInitiateData* _data_;
	_data_ = _data;
	_g_free0 (_data_->number);
	_g_free0 (_data_->ctype);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceInitiateData, _data_);
}


static void dbus_service_device_real_initiate (FreeSmartphoneGSMCall* base, const gchar* number, const gchar* ctype, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceInitiateData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceInitiateData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_initiate);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_initiate_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = number;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->number = _tmp2_;
	_tmp3_ = ctype;
	_tmp4_ = g_strdup (_tmp3_);
	_data_->ctype = _tmp4_;
	dbus_service_device_real_initiate_co (_data_);
}


static gint dbus_service_device_real_initiate_finish (FreeSmartphoneGSMCall* base, GAsyncResult* _res_, GError** error) {
	gint result;
	DbusServiceDeviceInitiateData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return 0;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static void dbus_service_device_initiate_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceInitiateData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_initiate_co (_data_);
}


static gboolean dbus_service_device_real_initiate_co (DbusServiceDeviceInitiateData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_CALL_INITIATE, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmCallInitiate*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->number;
	_data_->_tmp4_ = _data_->ctype;
	_data_->_state_ = 1;
	fso_gsm_call_initiate_run (_data_->_tmp2_, _data_->_tmp3_, _data_->_tmp4_, dbus_service_device_initiate_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_call_initiate_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp5_ = _data_->m;
	_data_->_tmp6_ = fso_gsm_call_initiate_get_id (_data_->_tmp5_);
	_data_->_tmp7_ = _data_->_tmp6_;
	_data_->result = _data_->_tmp7_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_join_data_free (gpointer _data) {
	DbusServiceDeviceJoinData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceJoinData, _data_);
}


static void dbus_service_device_real_join (FreeSmartphoneGSMCall* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceJoinData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceJoinData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_join);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_join_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_join_co (_data_);
}


static void dbus_service_device_real_join_finish (FreeSmartphoneGSMCall* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceJoinData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static gboolean dbus_service_device_real_join_co (DbusServiceDeviceJoinData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void _vala_FreeSmartphoneGSMCallDetail_array_free (FreeSmartphoneGSMCallDetail* array, gint array_length) {
	if (array != NULL) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			free_smartphone_gsm_call_detail_destroy (&array[i]);
		}
	}
	g_free (array);
}


static void dbus_service_device_real_list_calls_data_free (gpointer _data) {
	DbusServiceDeviceListCallsData* _data_;
	_data_ = _data;
	_data_->result = (_vala_FreeSmartphoneGSMCallDetail_array_free (_data_->result, _data_->result_length1), NULL);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceListCallsData, _data_);
}


static void dbus_service_device_real_list_calls (FreeSmartphoneGSMCall* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceListCallsData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceListCallsData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_list_calls);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_list_calls_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_list_calls_co (_data_);
}


static FreeSmartphoneGSMCallDetail* dbus_service_device_real_list_calls_finish (FreeSmartphoneGSMCall* base, GAsyncResult* _res_, int* result_length1, GError** error) {
	FreeSmartphoneGSMCallDetail* result;
	DbusServiceDeviceListCallsData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	*result_length1 = _data_->result_length1;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_list_calls_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceListCallsData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_list_calls_co (_data_);
}


static FreeSmartphoneGSMCallDetail* _vala_array_dup4 (FreeSmartphoneGSMCallDetail* self, int length) {
	FreeSmartphoneGSMCallDetail* result;
	int i;
	result = g_new0 (FreeSmartphoneGSMCallDetail, length);
	for (i = 0; i < length; i++) {
		FreeSmartphoneGSMCallDetail _tmp0_ = {0};
		free_smartphone_gsm_call_detail_copy (&self[i], &_tmp0_);
		result[i] = _tmp0_;
	}
	return result;
}


static gboolean dbus_service_device_real_list_calls_co (DbusServiceDeviceListCallsData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_CALL_LIST_CALLS, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmCallListCalls*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_call_list_calls_run (_data_->_tmp2_, dbus_service_device_list_calls_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_call_list_calls_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_call_list_calls_get_calls (_data_->_tmp3_, &_data_->_tmp4__length1);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->_tmp5__length1 = _data_->_tmp4__length1;
	_data_->_tmp6_ = (_data_->_tmp5_ != NULL) ? _vala_array_dup4 (_data_->_tmp5_, _data_->_tmp5__length1) : ((gpointer) _data_->_tmp5_);
	_data_->_tmp6__length1 = _data_->_tmp5__length1;
	_data_->_tmp7_ = _data_->_tmp6_;
	_data_->_tmp7__length1 = _data_->_tmp6__length1;
	_data_->result_length1 = _data_->_tmp7__length1;
	_data_->result = _data_->_tmp7_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_release_data_free (gpointer _data) {
	DbusServiceDeviceReleaseData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceReleaseData, _data_);
}


static void dbus_service_device_real_release (FreeSmartphoneGSMCall* base, gint id, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceReleaseData* _data_;
	DBusServiceDevice* _tmp0_;
	gint _tmp1_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceReleaseData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_release);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_release_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = id;
	_data_->id = _tmp1_;
	dbus_service_device_real_release_co (_data_);
}


static void dbus_service_device_real_release_finish (FreeSmartphoneGSMCall* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceReleaseData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_release_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceReleaseData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_release_co (_data_);
}


static gboolean dbus_service_device_real_release_co (DbusServiceDeviceReleaseData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_CALL_RELEASE, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmCallRelease*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->id;
	_data_->_state_ = 1;
	fso_gsm_call_release_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_release_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_call_release_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_release_all_data_free (gpointer _data) {
	DbusServiceDeviceReleaseAllData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceReleaseAllData, _data_);
}


static void dbus_service_device_real_release_all (FreeSmartphoneGSMCall* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceReleaseAllData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceReleaseAllData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_release_all);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_release_all_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_release_all_co (_data_);
}


static void dbus_service_device_real_release_all_finish (FreeSmartphoneGSMCall* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceReleaseAllData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_release_all_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceReleaseAllData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_release_all_co (_data_);
}


static gboolean dbus_service_device_real_release_all_co (DbusServiceDeviceReleaseAllData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_CALL_RELEASE_ALL, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmCallReleaseAll*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_call_release_all_run (_data_->_tmp2_, dbus_service_device_release_all_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_call_release_all_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_release_held_data_free (gpointer _data) {
	DbusServiceDeviceReleaseHeldData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceReleaseHeldData, _data_);
}


static void dbus_service_device_real_release_held (FreeSmartphoneGSMCall* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceReleaseHeldData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceReleaseHeldData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_release_held);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_release_held_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_release_held_co (_data_);
}


static void dbus_service_device_real_release_held_finish (FreeSmartphoneGSMCall* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceReleaseHeldData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static gboolean dbus_service_device_real_release_held_co (DbusServiceDeviceReleaseHeldData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_send_dtmf_data_free (gpointer _data) {
	DbusServiceDeviceSendDtmfData* _data_;
	_data_ = _data;
	_g_free0 (_data_->tones);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSendDtmfData, _data_);
}


static void dbus_service_device_real_send_dtmf (FreeSmartphoneGSMCall* base, const gchar* tones, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSendDtmfData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSendDtmfData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_send_dtmf);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_send_dtmf_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = tones;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->tones = _tmp2_;
	dbus_service_device_real_send_dtmf_co (_data_);
}


static void dbus_service_device_real_send_dtmf_finish (FreeSmartphoneGSMCall* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSendDtmfData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_send_dtmf_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSendDtmfData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_send_dtmf_co (_data_);
}


static gboolean dbus_service_device_real_send_dtmf_co (DbusServiceDeviceSendDtmfData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = _data_->tones;
	fso_gsm_validateDtmfTones (_data_->_tmp0_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp1_ = dbus_service_device_modem;
	_data_->_tmp2_ = NULL;
	_data_->_tmp2_ = fso_gsm_modem_createMediator (_data_->_tmp1_, FSO_GSM_TYPE_CALL_SEND_DTMF, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmCallSendDtmf*) _data_->_tmp2_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = _data_->tones;
	_data_->_state_ = 1;
	fso_gsm_call_send_dtmf_run (_data_->_tmp3_, _data_->_tmp4_, dbus_service_device_send_dtmf_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_call_send_dtmf_run_finish (_data_->_tmp3_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_transfer_data_free (gpointer _data) {
	DbusServiceDeviceTransferData* _data_;
	_data_ = _data;
	_g_free0 (_data_->number);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceTransferData, _data_);
}


static void dbus_service_device_real_transfer (FreeSmartphoneGSMCall* base, const gchar* number, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceTransferData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceTransferData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_transfer);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_transfer_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = number;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->number = _tmp2_;
	dbus_service_device_real_transfer_co (_data_);
}


static void dbus_service_device_real_transfer_finish (FreeSmartphoneGSMCall* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceTransferData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static gboolean dbus_service_device_real_transfer_co (DbusServiceDeviceTransferData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_activate_context_data_free (gpointer _data) {
	DbusServiceDeviceActivateContextData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceActivateContextData, _data_);
}


static void dbus_service_device_real_activate_context (FreeSmartphoneGSMPDP* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceActivateContextData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceActivateContextData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_activate_context);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_activate_context_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_activate_context_co (_data_);
}


static void dbus_service_device_real_activate_context_finish (FreeSmartphoneGSMPDP* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceActivateContextData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_activate_context_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceActivateContextData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_activate_context_co (_data_);
}


static gboolean dbus_service_device_real_activate_context_co (DbusServiceDeviceActivateContextData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_PDP_ACTIVATE_CONTEXT, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmPdpActivateContext*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_pdp_activate_context_run (_data_->_tmp2_, dbus_service_device_activate_context_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_pdp_activate_context_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_deactivate_context_data_free (gpointer _data) {
	DbusServiceDeviceDeactivateContextData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceDeactivateContextData, _data_);
}


static void dbus_service_device_real_deactivate_context (FreeSmartphoneGSMPDP* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceDeactivateContextData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceDeactivateContextData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_deactivate_context);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_deactivate_context_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_deactivate_context_co (_data_);
}


static void dbus_service_device_real_deactivate_context_finish (FreeSmartphoneGSMPDP* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceDeactivateContextData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_deactivate_context_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceDeactivateContextData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_deactivate_context_co (_data_);
}


static gboolean dbus_service_device_real_deactivate_context_co (DbusServiceDeviceDeactivateContextData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_PDP_DEACTIVATE_CONTEXT, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmPdpDeactivateContext*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_pdp_deactivate_context_run (_data_->_tmp2_, dbus_service_device_deactivate_context_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_pdp_deactivate_context_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_context_status_data_free (gpointer _data) {
	DbusServiceDeviceGetContextStatusData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetContextStatusData, _data_);
}


static void dbus_service_device_real_get_context_status (FreeSmartphoneGSMPDP* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetContextStatusData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetContextStatusData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_context_status);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_context_status_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_context_status_co (_data_);
}


static void dbus_service_device_real_get_context_status_finish (FreeSmartphoneGSMPDP* base, GAsyncResult* _res_, FreeSmartphoneGSMContextStatus* status, GHashTable** properties, GError** error) {
	DbusServiceDeviceGetContextStatusData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	if (status) {
		*status = _data_->status;
	}
	if (properties) {
		*properties = _data_->properties;
	} else {
		_g_hash_table_unref0 (_data_->properties);
	}
	_data_->properties = NULL;
}


static gboolean dbus_service_device_real_get_context_status_co (DbusServiceDeviceGetContextStatusData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = fso_gsm_modem_get_pdphandler (_data_->_tmp0_);
	_data_->_tmp2_ = _data_->_tmp1_;
	_data_->_tmp3_ = fso_gsm_ipdp_handler_get_status (_data_->_tmp2_);
	_data_->_tmp4_ = _data_->_tmp3_;
	_data_->status = _data_->_tmp4_;
	_data_->_tmp5_ = dbus_service_device_modem;
	_data_->_tmp6_ = fso_gsm_modem_get_pdphandler (_data_->_tmp5_);
	_data_->_tmp7_ = _data_->_tmp6_;
	_data_->_tmp8_ = fso_gsm_ipdp_handler_get_properties (_data_->_tmp7_);
	_data_->_tmp9_ = _data_->_tmp8_;
	_data_->_tmp10_ = _g_hash_table_ref0 (_data_->_tmp9_);
	_g_hash_table_unref0 (_data_->properties);
	_data_->properties = _data_->_tmp10_;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_credentials_data_free (gpointer _data) {
	DbusServiceDeviceGetCredentialsData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetCredentialsData, _data_);
}


static void dbus_service_device_real_get_credentials (FreeSmartphoneGSMPDP* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetCredentialsData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetCredentialsData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_credentials);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_credentials_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_credentials_co (_data_);
}


static void dbus_service_device_real_get_credentials_finish (FreeSmartphoneGSMPDP* base, GAsyncResult* _res_, gchar** apn, gchar** username, gchar** password, GError** error) {
	DbusServiceDeviceGetCredentialsData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	if (apn) {
		*apn = _data_->apn;
	} else {
		_g_free0 (_data_->apn);
	}
	_data_->apn = NULL;
	if (username) {
		*username = _data_->username;
	} else {
		_g_free0 (_data_->username);
	}
	_data_->username = NULL;
	if (password) {
		*password = _data_->password;
	} else {
		_g_free0 (_data_->password);
	}
	_data_->password = NULL;
}


static void dbus_service_device_get_credentials_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetCredentialsData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_credentials_co (_data_);
}


static gboolean dbus_service_device_real_get_credentials_co (DbusServiceDeviceGetCredentialsData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_PDP_GET_CREDENTIALS, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmPdpGetCredentials*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_pdp_get_credentials_run (_data_->_tmp2_, dbus_service_device_get_credentials_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_pdp_get_credentials_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_pdp_get_credentials_get_apn (_data_->_tmp3_);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->_tmp6_ = g_strdup (_data_->_tmp5_);
	_g_free0 (_data_->apn);
	_data_->apn = _data_->_tmp6_;
	_data_->_tmp7_ = _data_->m;
	_data_->_tmp8_ = fso_gsm_pdp_get_credentials_get_username (_data_->_tmp7_);
	_data_->_tmp9_ = _data_->_tmp8_;
	_data_->_tmp10_ = g_strdup (_data_->_tmp9_);
	_g_free0 (_data_->username);
	_data_->username = _data_->_tmp10_;
	_data_->_tmp11_ = _data_->m;
	_data_->_tmp12_ = fso_gsm_pdp_get_credentials_get_password (_data_->_tmp11_);
	_data_->_tmp13_ = _data_->_tmp12_;
	_data_->_tmp14_ = g_strdup (_data_->_tmp13_);
	_g_free0 (_data_->password);
	_data_->password = _data_->_tmp14_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_roaming_allowed_data_free (gpointer _data) {
	DbusServiceDeviceGetRoamingAllowedData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetRoamingAllowedData, _data_);
}


static void dbus_service_device_real_get_roaming_allowed (FreeSmartphoneGSMPDP* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetRoamingAllowedData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetRoamingAllowedData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_roaming_allowed);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_roaming_allowed_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_roaming_allowed_co (_data_);
}


static gboolean dbus_service_device_real_get_roaming_allowed_finish (FreeSmartphoneGSMPDP* base, GAsyncResult* _res_, GError** error) {
	gboolean result;
	DbusServiceDeviceGetRoamingAllowedData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return FALSE;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	return result;
}


static gboolean dbus_service_device_real_get_roaming_allowed_co (DbusServiceDeviceGetRoamingAllowedData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_data (_data_->_tmp0_);
	_data_->_tmp2_ = _data_->_tmp1_;
	_data_->_tmp3_ = _data_->_tmp2_->roamingAllowed;
	_data_->_tmp4_ = _data_->_tmp3_;
	_g_object_unref0 (_data_->_tmp2_);
	_data_->result = _data_->_tmp4_;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_set_roaming_allowed_data_free (gpointer _data) {
	DbusServiceDeviceSetRoamingAllowedData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSetRoamingAllowedData, _data_);
}


static void dbus_service_device_real_set_roaming_allowed (FreeSmartphoneGSMPDP* base, gboolean state, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSetRoamingAllowedData* _data_;
	DBusServiceDevice* _tmp0_;
	gboolean _tmp1_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSetRoamingAllowedData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_set_roaming_allowed);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_set_roaming_allowed_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = state;
	_data_->state = _tmp1_;
	dbus_service_device_real_set_roaming_allowed_co (_data_);
}


static void dbus_service_device_real_set_roaming_allowed_finish (FreeSmartphoneGSMPDP* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSetRoamingAllowedData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_set_roaming_allowed_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSetRoamingAllowedData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_set_roaming_allowed_co (_data_);
}


static gboolean dbus_service_device_real_set_roaming_allowed_co (DbusServiceDeviceSetRoamingAllowedData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_data (_data_->_tmp0_);
	_data_->_tmp2_ = _data_->_tmp1_;
	_data_->_tmp3_ = _data_->state;
	_data_->_tmp2_->roamingAllowed = _data_->_tmp3_;
	_g_object_unref0 (_data_->_tmp2_);
	_data_->_tmp4_ = dbus_service_device_modem;
	_data_->_tmp5_ = fso_gsm_modem_get_pdphandler (_data_->_tmp4_);
	_data_->_tmp6_ = _data_->_tmp5_;
	_data_->_state_ = 1;
	fso_gsm_ipdp_handler_syncStatus (_data_->_tmp6_, dbus_service_device_set_roaming_allowed_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_ipdp_handler_syncStatus_finish (_data_->_tmp6_, _data_->_res_);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_internal_status_update_data_free (gpointer _data) {
	DbusServiceDeviceInternalStatusUpdateData* _data_;
	_data_ = _data;
	_g_free0 (_data_->status);
	_g_hash_table_unref0 (_data_->properties);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceInternalStatusUpdateData, _data_);
}


static void dbus_service_device_real_internal_status_update (FreeSmartphoneGSMPDP* base, const gchar* status, GHashTable* properties, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceInternalStatusUpdateData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	GHashTable* _tmp3_;
	GHashTable* _tmp4_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceInternalStatusUpdateData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_internal_status_update);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_internal_status_update_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = status;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->status = _tmp2_;
	_tmp3_ = properties;
	_tmp4_ = _g_hash_table_ref0 (_tmp3_);
	_data_->properties = _tmp4_;
	dbus_service_device_real_internal_status_update_co (_data_);
}


static void dbus_service_device_real_internal_status_update_finish (FreeSmartphoneGSMPDP* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceInternalStatusUpdateData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_internal_status_update_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceInternalStatusUpdateData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_internal_status_update_co (_data_);
}


static gboolean dbus_service_device_real_internal_status_update_co (DbusServiceDeviceInternalStatusUpdateData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = fso_gsm_modem_get_pdphandler (_data_->_tmp0_);
	_data_->_tmp2_ = _data_->_tmp1_;
	_data_->_tmp3_ = _data_->status;
	_data_->_tmp4_ = _data_->properties;
	_data_->_state_ = 1;
	fso_gsm_ipdp_handler_statusUpdate (_data_->_tmp2_, _data_->_tmp3_, _data_->_tmp4_, dbus_service_device_internal_status_update_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_ipdp_handler_statusUpdate_finish (_data_->_tmp2_, _data_->_res_);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_set_credentials_data_free (gpointer _data) {
	DbusServiceDeviceSetCredentialsData* _data_;
	_data_ = _data;
	_g_free0 (_data_->apn);
	_g_free0 (_data_->username);
	_g_free0 (_data_->password);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSetCredentialsData, _data_);
}


static void dbus_service_device_real_set_credentials (FreeSmartphoneGSMPDP* base, const gchar* apn, const gchar* username, const gchar* password, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSetCredentialsData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	const gchar* _tmp5_;
	gchar* _tmp6_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSetCredentialsData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_set_credentials);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_set_credentials_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = apn;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->apn = _tmp2_;
	_tmp3_ = username;
	_tmp4_ = g_strdup (_tmp3_);
	_data_->username = _tmp4_;
	_tmp5_ = password;
	_tmp6_ = g_strdup (_tmp5_);
	_data_->password = _tmp6_;
	dbus_service_device_real_set_credentials_co (_data_);
}


static void dbus_service_device_real_set_credentials_finish (FreeSmartphoneGSMPDP* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSetCredentialsData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_set_credentials_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSetCredentialsData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_set_credentials_co (_data_);
}


static gboolean dbus_service_device_real_set_credentials_co (DbusServiceDeviceSetCredentialsData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_PDP_SET_CREDENTIALS, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmPdpSetCredentials*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->apn;
	_data_->_tmp4_ = _data_->username;
	_data_->_tmp5_ = _data_->password;
	_data_->_state_ = 1;
	fso_gsm_pdp_set_credentials_run (_data_->_tmp2_, _data_->_tmp3_, _data_->_tmp4_, _data_->_tmp5_, dbus_service_device_set_credentials_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_pdp_set_credentials_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_cell_broadcast_subscriptions_data_free (gpointer _data) {
	DbusServiceDeviceGetCellBroadcastSubscriptionsData* _data_;
	_data_ = _data;
	_g_free0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetCellBroadcastSubscriptionsData, _data_);
}


static void dbus_service_device_real_get_cell_broadcast_subscriptions (FreeSmartphoneGSMCB* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetCellBroadcastSubscriptionsData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetCellBroadcastSubscriptionsData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_cell_broadcast_subscriptions);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_cell_broadcast_subscriptions_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_cell_broadcast_subscriptions_co (_data_);
}


static gchar* dbus_service_device_real_get_cell_broadcast_subscriptions_finish (FreeSmartphoneGSMCB* base, GAsyncResult* _res_, GError** error) {
	gchar* result;
	DbusServiceDeviceGetCellBroadcastSubscriptionsData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_get_cell_broadcast_subscriptions_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetCellBroadcastSubscriptionsData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_cell_broadcast_subscriptions_co (_data_);
}


static gboolean dbus_service_device_real_get_cell_broadcast_subscriptions_co (DbusServiceDeviceGetCellBroadcastSubscriptionsData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_CB_GET_CELL_BROADCAST_SUBSCRIPTIONS, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmCbGetCellBroadcastSubscriptions*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_cb_get_cell_broadcast_subscriptions_run (_data_->_tmp2_, dbus_service_device_get_cell_broadcast_subscriptions_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_cb_get_cell_broadcast_subscriptions_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_cb_get_cell_broadcast_subscriptions_get_subscriptions (_data_->_tmp3_);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->_tmp6_ = g_strdup (_data_->_tmp5_);
	_data_->result = _data_->_tmp6_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_set_cell_broadcast_subscriptions_data_free (gpointer _data) {
	DbusServiceDeviceSetCellBroadcastSubscriptionsData* _data_;
	_data_ = _data;
	_g_free0 (_data_->subscriptions);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSetCellBroadcastSubscriptionsData, _data_);
}


static void dbus_service_device_real_set_cell_broadcast_subscriptions (FreeSmartphoneGSMCB* base, const gchar* subscriptions, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSetCellBroadcastSubscriptionsData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSetCellBroadcastSubscriptionsData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_set_cell_broadcast_subscriptions);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_set_cell_broadcast_subscriptions_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = subscriptions;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->subscriptions = _tmp2_;
	dbus_service_device_real_set_cell_broadcast_subscriptions_co (_data_);
}


static void dbus_service_device_real_set_cell_broadcast_subscriptions_finish (FreeSmartphoneGSMCB* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSetCellBroadcastSubscriptionsData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_set_cell_broadcast_subscriptions_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSetCellBroadcastSubscriptionsData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_set_cell_broadcast_subscriptions_co (_data_);
}


static gboolean dbus_service_device_real_set_cell_broadcast_subscriptions_co (DbusServiceDeviceSetCellBroadcastSubscriptionsData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_CB_SET_CELL_BROADCAST_SUBSCRIPTIONS, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmCbSetCellBroadcastSubscriptions*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->subscriptions;
	_data_->_state_ = 1;
	fso_gsm_cb_set_cell_broadcast_subscriptions_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_set_cell_broadcast_subscriptions_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_cb_set_cell_broadcast_subscriptions_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_home_zone_status_data_free (gpointer _data) {
	DbusServiceDeviceGetHomeZoneStatusData* _data_;
	_data_ = _data;
	_g_free0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetHomeZoneStatusData, _data_);
}


static void dbus_service_device_real_get_home_zone_status (FreeSmartphoneGSMHZ* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetHomeZoneStatusData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetHomeZoneStatusData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_home_zone_status);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_home_zone_status_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_home_zone_status_co (_data_);
}


static gchar* dbus_service_device_real_get_home_zone_status_finish (FreeSmartphoneGSMHZ* base, GAsyncResult* _res_, GError** error) {
	gchar* result;
	DbusServiceDeviceGetHomeZoneStatusData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static gboolean dbus_service_device_real_get_home_zone_status_co (DbusServiceDeviceGetHomeZoneStatusData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_REGISTERED, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_known_home_zones_data_free (gpointer _data) {
	DbusServiceDeviceGetKnownHomeZonesData* _data_;
	_data_ = _data;
	_data_->result = (_vala_array_free (_data_->result, _data_->result_length1, (GDestroyNotify) g_free), NULL);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetKnownHomeZonesData, _data_);
}


static void dbus_service_device_real_get_known_home_zones (FreeSmartphoneGSMHZ* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetKnownHomeZonesData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetKnownHomeZonesData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_known_home_zones);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_known_home_zones_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_known_home_zones_co (_data_);
}


static gchar** dbus_service_device_real_get_known_home_zones_finish (FreeSmartphoneGSMHZ* base, GAsyncResult* _res_, int* result_length1, GError** error) {
	gchar** result;
	DbusServiceDeviceGetKnownHomeZonesData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	*result_length1 = _data_->result_length1;
	_data_->result = NULL;
	return result;
}


static gboolean dbus_service_device_real_get_known_home_zones_co (DbusServiceDeviceGetKnownHomeZonesData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_SIM_READY, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_serving_cell_information_data_free (gpointer _data) {
	DbusServiceDeviceGetServingCellInformationData* _data_;
	_data_ = _data;
	_g_hash_table_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetServingCellInformationData, _data_);
}


static void dbus_service_device_real_get_serving_cell_information (FreeSmartphoneGSMMonitor* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetServingCellInformationData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetServingCellInformationData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_serving_cell_information);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_serving_cell_information_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_serving_cell_information_co (_data_);
}


static GHashTable* dbus_service_device_real_get_serving_cell_information_finish (FreeSmartphoneGSMMonitor* base, GAsyncResult* _res_, GError** error) {
	GHashTable* result;
	DbusServiceDeviceGetServingCellInformationData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_get_serving_cell_information_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetServingCellInformationData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_serving_cell_information_co (_data_);
}


static gboolean dbus_service_device_real_get_serving_cell_information_co (DbusServiceDeviceGetServingCellInformationData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_MONITOR_GET_SERVING_CELL_INFORMATION, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmMonitorGetServingCellInformation*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_monitor_get_serving_cell_information_run (_data_->_tmp2_, dbus_service_device_get_serving_cell_information_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_monitor_get_serving_cell_information_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_monitor_get_serving_cell_information_get_cell (_data_->_tmp3_);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->_tmp6_ = _g_hash_table_ref0 (_data_->_tmp5_);
	_data_->result = _data_->_tmp6_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_neighbour_cell_information_data_free (gpointer _data) {
	DbusServiceDeviceGetNeighbourCellInformationData* _data_;
	_data_ = _data;
	_data_->result = (_vala_array_free (_data_->result, _data_->result_length1, (GDestroyNotify) g_hash_table_unref), NULL);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetNeighbourCellInformationData, _data_);
}


static void dbus_service_device_real_get_neighbour_cell_information (FreeSmartphoneGSMMonitor* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetNeighbourCellInformationData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetNeighbourCellInformationData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_neighbour_cell_information);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_neighbour_cell_information_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_neighbour_cell_information_co (_data_);
}


static GHashTable** dbus_service_device_real_get_neighbour_cell_information_finish (FreeSmartphoneGSMMonitor* base, GAsyncResult* _res_, int* result_length1, GError** error) {
	GHashTable** result;
	DbusServiceDeviceGetNeighbourCellInformationData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	*result_length1 = _data_->result_length1;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_get_neighbour_cell_information_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetNeighbourCellInformationData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_neighbour_cell_information_co (_data_);
}


static GHashTable** _vala_array_dup5 (GHashTable** self, int length) {
	GHashTable** result;
	int i;
	result = g_new0 (GHashTable*, length + 1);
	for (i = 0; i < length; i++) {
		GHashTable* _tmp0_;
		_tmp0_ = _g_hash_table_ref0 (self[i]);
		result[i] = _tmp0_;
	}
	return result;
}


static gboolean dbus_service_device_real_get_neighbour_cell_information_co (DbusServiceDeviceGetNeighbourCellInformationData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_MONITOR_GET_NEIGHBOUR_CELL_INFORMATION, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmMonitorGetNeighbourCellInformation*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_monitor_get_neighbour_cell_information_run (_data_->_tmp2_, dbus_service_device_get_neighbour_cell_information_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_monitor_get_neighbour_cell_information_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = fso_gsm_monitor_get_neighbour_cell_information_get_cells (_data_->_tmp3_, &_data_->_tmp4__length1);
	_data_->_tmp5_ = _data_->_tmp4_;
	_data_->_tmp5__length1 = _data_->_tmp4__length1;
	_data_->_tmp6_ = (_data_->_tmp5_ != NULL) ? _vala_array_dup5 (_data_->_tmp5_, _data_->_tmp5__length1) : ((gpointer) _data_->_tmp5_);
	_data_->_tmp6__length1 = _data_->_tmp5__length1;
	_data_->_tmp7_ = _data_->_tmp6_;
	_data_->_tmp7__length1 = _data_->_tmp6__length1;
	_data_->result_length1 = _data_->_tmp7__length1;
	_data_->result = _data_->_tmp7_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_voice_mailbox_number_data_free (gpointer _data) {
	DbusServiceDeviceGetVoiceMailboxNumberData* _data_;
	_data_ = _data;
	_g_free0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetVoiceMailboxNumberData, _data_);
}


static void dbus_service_device_real_get_voice_mailbox_number (FreeSmartphoneGSMVoiceMail* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetVoiceMailboxNumberData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetVoiceMailboxNumberData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_voice_mailbox_number);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_voice_mailbox_number_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_voice_mailbox_number_co (_data_);
}


static gchar* dbus_service_device_real_get_voice_mailbox_number_finish (FreeSmartphoneGSMVoiceMail* base, GAsyncResult* _res_, GError** error) {
	gchar* result;
	DbusServiceDeviceGetVoiceMailboxNumberData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void dbus_service_device_get_voice_mailbox_number_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceGetVoiceMailboxNumberData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_get_voice_mailbox_number_co (_data_);
}


static gboolean dbus_service_device_real_get_voice_mailbox_number_co (DbusServiceDeviceGetVoiceMailboxNumberData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_VOICE_MAILBOX_GET_NUMBER, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmVoiceMailboxGetNumber*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_state_ = 1;
	fso_gsm_voice_mailbox_get_number_run (_data_->_tmp2_, dbus_service_device_get_voice_mailbox_number_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_voice_mailbox_get_number_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp3_ = _data_->m;
	_data_->_tmp4_ = _data_->_tmp3_->number;
	_data_->_tmp5_ = g_strdup (_data_->_tmp4_);
	_data_->result = _data_->_tmp5_;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_set_voice_mailbox_number_data_free (gpointer _data) {
	DbusServiceDeviceSetVoiceMailboxNumberData* _data_;
	_data_ = _data;
	_g_free0 (_data_->number);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceSetVoiceMailboxNumberData, _data_);
}


static void dbus_service_device_real_set_voice_mailbox_number (FreeSmartphoneGSMVoiceMail* base, const gchar* number, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceSetVoiceMailboxNumberData* _data_;
	DBusServiceDevice* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceSetVoiceMailboxNumberData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_set_voice_mailbox_number);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_set_voice_mailbox_number_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = number;
	_tmp2_ = g_strdup (_tmp1_);
	_data_->number = _tmp2_;
	dbus_service_device_real_set_voice_mailbox_number_co (_data_);
}


static void dbus_service_device_real_set_voice_mailbox_number_finish (FreeSmartphoneGSMVoiceMail* base, GAsyncResult* _res_, GError** error) {
	DbusServiceDeviceSetVoiceMailboxNumberData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_device_set_voice_mailbox_number_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	DbusServiceDeviceSetVoiceMailboxNumberData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_device_real_set_voice_mailbox_number_co (_data_);
}


static gboolean dbus_service_device_real_set_voice_mailbox_number_co (DbusServiceDeviceSetVoiceMailboxNumberData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = dbus_service_device_modem;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = fso_gsm_modem_createMediator (_data_->_tmp0_, FSO_GSM_TYPE_VOICE_MAILBOX_SET_NUMBER, (GBoxedCopyFunc) g_object_ref, g_object_unref, &_data_->_inner_error_);
	_data_->m = (FsoGsmVoiceMailboxSetNumber*) _data_->_tmp1_;
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp2_ = _data_->m;
	_data_->_tmp3_ = _data_->number;
	_data_->_state_ = 1;
	fso_gsm_voice_mailbox_set_number_run (_data_->_tmp2_, _data_->_tmp3_, dbus_service_device_set_voice_mailbox_number_ready, _data_);
	return FALSE;
	_state_1:
	fso_gsm_voice_mailbox_set_number_run_finish (_data_->_tmp2_, _data_->_res_, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			_g_object_unref0 (_data_->m);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			_g_object_unref0 (_data_->m);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_g_object_unref0 (_data_->m);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_real_get_stored_voice_mails_data_free (gpointer _data) {
	DbusServiceDeviceGetStoredVoiceMailsData* _data_;
	_data_ = _data;
	_data_->result = (_vala_array_free (_data_->result, _data_->result_length1, (GDestroyNotify) g_free), NULL);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceDeviceGetStoredVoiceMailsData, _data_);
}


static void dbus_service_device_real_get_stored_voice_mails (FreeSmartphoneGSMVoiceMail* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceDevice * self;
	DbusServiceDeviceGetStoredVoiceMailsData* _data_;
	DBusServiceDevice* _tmp0_;
	self = (DBusServiceDevice*) base;
	_data_ = g_slice_new0 (DbusServiceDeviceGetStoredVoiceMailsData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_device_real_get_stored_voice_mails);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_device_real_get_stored_voice_mails_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_device_real_get_stored_voice_mails_co (_data_);
}


static gchar** dbus_service_device_real_get_stored_voice_mails_finish (FreeSmartphoneGSMVoiceMail* base, GAsyncResult* _res_, int* result_length1, GError** error) {
	gchar** result;
	DbusServiceDeviceGetStoredVoiceMailsData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	*result_length1 = _data_->result_length1;
	_data_->result = NULL;
	return result;
}


static gboolean dbus_service_device_real_get_stored_voice_mails_co (DbusServiceDeviceGetStoredVoiceMailsData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	dbus_service_device_checkAvailability (_data_->self, FSO_GSM_MODEM_STATUS_ALIVE_NO_SIM, &_data_->_inner_error_);
	if (_data_->_inner_error_ != NULL) {
		if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	_data_->_tmp0_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Not yet implemented");
	_data_->_inner_error_ = _data_->_tmp0_;
	if ((((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
		g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
		g_error_free (_data_->_inner_error_);
		if (_data_->_state_ == 0) {
			g_simple_async_result_complete_in_idle (_data_->_async_result);
		} else {
			g_simple_async_result_complete (_data_->_async_result);
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	} else {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
		g_clear_error (&_data_->_inner_error_);
		return FALSE;
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_device_class_init (DBusServiceDeviceClass * klass) {
	dbus_service_device_parent_class = g_type_class_peek_parent (klass);
	FSO_FRAMEWORK_ABSTRACT_OBJECT_CLASS (klass)->repr = dbus_service_device_real_repr;
	G_OBJECT_CLASS (klass)->finalize = dbus_service_device_finalize;
}


static void dbus_service_device_free_smartphone_info_interface_init (FreeSmartphoneInfoIface * iface) {
	dbus_service_device_free_smartphone_info_parent_iface = g_type_interface_peek_parent (iface);
	iface->get_info = (GHashTable* (*)(FreeSmartphoneInfo*, GError**)) dbus_service_device_real_get_info;
	iface->get_info_finish = dbus_service_device_real_get_info_finish;
}


static void dbus_service_device_free_smartphone_device_realtime_clock_interface_init (FreeSmartphoneDeviceRealtimeClockIface * iface) {
	dbus_service_device_free_smartphone_device_realtime_clock_parent_iface = g_type_interface_peek_parent (iface);
	iface->get_current_time = (gint (*)(FreeSmartphoneDeviceRealtimeClock*, GError**)) dbus_service_device_real_get_current_time;
	iface->get_current_time_finish = dbus_service_device_real_get_current_time_finish;
	iface->set_current_time = (void (*)(FreeSmartphoneDeviceRealtimeClock*, gint, GError**)) dbus_service_device_real_set_current_time;
	iface->set_current_time_finish = dbus_service_device_real_set_current_time_finish;
	iface->get_wakeup_time = (gint (*)(FreeSmartphoneDeviceRealtimeClock*, GError**)) dbus_service_device_real_get_wakeup_time;
	iface->get_wakeup_time_finish = dbus_service_device_real_get_wakeup_time_finish;
	iface->set_wakeup_time = (void (*)(FreeSmartphoneDeviceRealtimeClock*, gint, GError**)) dbus_service_device_real_set_wakeup_time;
	iface->set_wakeup_time_finish = dbus_service_device_real_set_wakeup_time_finish;
}


static void dbus_service_device_free_smartphone_device_power_supply_interface_init (FreeSmartphoneDevicePowerSupplyIface * iface) {
	dbus_service_device_free_smartphone_device_power_supply_parent_iface = g_type_interface_peek_parent (iface);
	iface->get_power_status = (FreeSmartphoneDevicePowerStatus (*)(FreeSmartphoneDevicePowerSupply*, GError**)) dbus_service_device_real_get_power_status;
	iface->get_power_status_finish = dbus_service_device_real_get_power_status_finish;
	iface->get_capacity = (gint (*)(FreeSmartphoneDevicePowerSupply*, GError**)) dbus_service_device_real_get_capacity;
	iface->get_capacity_finish = dbus_service_device_real_get_capacity_finish;
}


static void dbus_service_device_free_smartphone_gsm_debug_interface_init (FreeSmartphoneGSMDebugIface * iface) {
	dbus_service_device_free_smartphone_gsm_debug_parent_iface = g_type_interface_peek_parent (iface);
	iface->debug_command = (gchar* (*)(FreeSmartphoneGSMDebug*, const gchar*, const gchar*, GError**)) dbus_service_device_real_debug_command;
	iface->debug_command_finish = dbus_service_device_real_debug_command_finish;
	iface->debug_inject_response = (void (*)(FreeSmartphoneGSMDebug*, const gchar*, const gchar*, GError**)) dbus_service_device_real_debug_inject_response;
	iface->debug_inject_response_finish = dbus_service_device_real_debug_inject_response_finish;
	iface->debug_ping = (void (*)(FreeSmartphoneGSMDebug*, GError**)) dbus_service_device_real_debug_ping;
	iface->debug_ping_finish = dbus_service_device_real_debug_ping_finish;
}


static void dbus_service_device_free_smartphone_gsm_device_interface_init (FreeSmartphoneGSMDeviceIface * iface) {
	dbus_service_device_free_smartphone_gsm_device_parent_iface = g_type_interface_peek_parent (iface);
	iface->get_functionality = (void (*)(FreeSmartphoneGSMDevice*, gchar**, gboolean*, gchar**, GError**)) dbus_service_device_real_get_functionality;
	iface->get_functionality_finish = dbus_service_device_real_get_functionality_finish;
	iface->get_features = (GHashTable* (*)(FreeSmartphoneGSMDevice*, GError**)) dbus_service_device_real_get_features;
	iface->get_features_finish = dbus_service_device_real_get_features_finish;
	iface->get_microphone_muted = (gboolean (*)(FreeSmartphoneGSMDevice*, GError**)) dbus_service_device_real_get_microphone_muted;
	iface->get_microphone_muted_finish = dbus_service_device_real_get_microphone_muted_finish;
	iface->get_speaker_volume = (gint (*)(FreeSmartphoneGSMDevice*, GError**)) dbus_service_device_real_get_speaker_volume;
	iface->get_speaker_volume_finish = dbus_service_device_real_get_speaker_volume_finish;
	iface->set_functionality = (void (*)(FreeSmartphoneGSMDevice*, const gchar*, gboolean, const gchar*, GError**)) dbus_service_device_real_set_functionality;
	iface->set_functionality_finish = dbus_service_device_real_set_functionality_finish;
	iface->set_microphone_muted = (void (*)(FreeSmartphoneGSMDevice*, gboolean, GError**)) dbus_service_device_real_set_microphone_muted;
	iface->set_microphone_muted_finish = dbus_service_device_real_set_microphone_muted_finish;
	iface->set_speaker_volume = (void (*)(FreeSmartphoneGSMDevice*, gint, GError**)) dbus_service_device_real_set_speaker_volume;
	iface->set_speaker_volume_finish = dbus_service_device_real_set_speaker_volume_finish;
	iface->get_device_status = (FreeSmartphoneGSMDeviceStatus (*)(FreeSmartphoneGSMDevice*, GError**)) dbus_service_device_real_get_device_status;
	iface->get_device_status_finish = dbus_service_device_real_get_device_status_finish;
}


static void dbus_service_device_free_smartphone_gsm_sim_interface_init (FreeSmartphoneGSMSIMIface * iface) {
	dbus_service_device_free_smartphone_gsm_sim_parent_iface = g_type_interface_peek_parent (iface);
	iface->change_auth_code = (void (*)(FreeSmartphoneGSMSIM*, const gchar*, const gchar*, GError**)) dbus_service_device_real_change_auth_code;
	iface->change_auth_code_finish = dbus_service_device_real_change_auth_code_finish;
	iface->delete_entry = (void (*)(FreeSmartphoneGSMSIM*, const gchar*, gint, GError**)) dbus_service_device_real_delete_entry;
	iface->delete_entry_finish = dbus_service_device_real_delete_entry_finish;
	iface->delete_message = (void (*)(FreeSmartphoneGSMSIM*, gint, GError**)) dbus_service_device_real_delete_message;
	iface->delete_message_finish = dbus_service_device_real_delete_message_finish;
	iface->get_auth_code_required = (gboolean (*)(FreeSmartphoneGSMSIM*, GError**)) dbus_service_device_real_get_auth_code_required;
	iface->get_auth_code_required_finish = dbus_service_device_real_get_auth_code_required_finish;
	iface->get_auth_status = (FreeSmartphoneGSMSIMAuthStatus (*)(FreeSmartphoneGSMSIM*, GError**)) dbus_service_device_real_get_auth_status;
	iface->get_auth_status_finish = dbus_service_device_real_get_auth_status_finish;
	iface->get_home_zone_parameters = (FreeSmartphoneGSMSIMHomeZone* (*)(FreeSmartphoneGSMSIM*, int*, GError**)) dbus_service_device_real_get_home_zone_parameters;
	iface->get_home_zone_parameters_finish = dbus_service_device_real_get_home_zone_parameters_finish;
	iface->get_phonebook_info = (void (*)(FreeSmartphoneGSMSIM*, const gchar*, gint*, gint*, gint*, GError**)) dbus_service_device_real_get_phonebook_info;
	iface->get_phonebook_info_finish = dbus_service_device_real_get_phonebook_info_finish;
	iface->get_service_center_number = (gchar* (*)(FreeSmartphoneGSMSIM*, GError**)) dbus_service_device_real_get_service_center_number;
	iface->get_service_center_number_finish = dbus_service_device_real_get_service_center_number_finish;
	iface->get_sim_info = (GHashTable* (*)(FreeSmartphoneGSMSIM*, GError**)) dbus_service_device_real_get_sim_info;
	iface->get_sim_info_finish = dbus_service_device_real_get_sim_info_finish;
	iface->get_unlock_counters = (GHashTable* (*)(FreeSmartphoneGSMSIM*, GError**)) dbus_service_device_real_get_unlock_counters;
	iface->get_unlock_counters_finish = dbus_service_device_real_get_unlock_counters_finish;
	iface->retrieve_message = (void (*)(FreeSmartphoneGSMSIM*, gint, gchar**, gchar**, gchar**, GHashTable**, GError**)) dbus_service_device_real_retrieve_message;
	iface->retrieve_message_finish = dbus_service_device_real_retrieve_message_finish;
	iface->retrieve_phonebook = (FreeSmartphoneGSMSIMEntry* (*)(FreeSmartphoneGSMSIM*, const gchar*, gint, gint, int*, GError**)) dbus_service_device_real_retrieve_phonebook;
	iface->retrieve_phonebook_finish = dbus_service_device_real_retrieve_phonebook_finish;
	iface->send_auth_code = (void (*)(FreeSmartphoneGSMSIM*, const gchar*, GError**)) dbus_service_device_real_send_auth_code;
	iface->send_auth_code_finish = dbus_service_device_real_send_auth_code_finish;
	iface->send_generic_sim_command = (gchar* (*)(FreeSmartphoneGSMSIM*, const gchar*, GError**)) dbus_service_device_real_send_generic_sim_command;
	iface->send_generic_sim_command_finish = dbus_service_device_real_send_generic_sim_command_finish;
	iface->send_restricted_sim_command = (gchar* (*)(FreeSmartphoneGSMSIM*, gint, gint, gint, gint, gint, const gchar*, GError**)) dbus_service_device_real_send_restricted_sim_command;
	iface->send_restricted_sim_command_finish = dbus_service_device_real_send_restricted_sim_command_finish;
	iface->send_stored_message = (void (*)(FreeSmartphoneGSMSIM*, gint, gint*, gchar**, GError**)) dbus_service_device_real_send_stored_message;
	iface->send_stored_message_finish = dbus_service_device_real_send_stored_message_finish;
	iface->set_auth_code_required = (void (*)(FreeSmartphoneGSMSIM*, gboolean, const gchar*, GError**)) dbus_service_device_real_set_auth_code_required;
	iface->set_auth_code_required_finish = dbus_service_device_real_set_auth_code_required_finish;
	iface->set_service_center_number = (void (*)(FreeSmartphoneGSMSIM*, const gchar*, GError**)) dbus_service_device_real_set_service_center_number;
	iface->set_service_center_number_finish = dbus_service_device_real_set_service_center_number_finish;
	iface->store_entry = (void (*)(FreeSmartphoneGSMSIM*, const gchar*, gint, const gchar*, const gchar*, GError**)) dbus_service_device_real_store_entry;
	iface->store_entry_finish = dbus_service_device_real_store_entry_finish;
	iface->store_message = (gint (*)(FreeSmartphoneGSMSIM*, const gchar*, const gchar*, GHashTable*, GError**)) dbus_service_device_real_store_message;
	iface->store_message_finish = dbus_service_device_real_store_message_finish;
	iface->unlock = (void (*)(FreeSmartphoneGSMSIM*, const gchar*, const gchar*, GError**)) dbus_service_device_real_unlock;
	iface->unlock_finish = dbus_service_device_real_unlock_finish;
}


static void dbus_service_device_free_smartphone_gsm_sms_interface_init (FreeSmartphoneGSMSMSIface * iface) {
	dbus_service_device_free_smartphone_gsm_sms_parent_iface = g_type_interface_peek_parent (iface);
	iface->get_size_for_text_message = (guint (*)(FreeSmartphoneGSMSMS*, const gchar*, GError**)) dbus_service_device_real_get_size_for_text_message;
	iface->get_size_for_text_message_finish = dbus_service_device_real_get_size_for_text_message_finish;
	iface->retrieve_text_messages = (FreeSmartphoneGSMSIMMessage* (*)(FreeSmartphoneGSMSMS*, int*, GError**)) dbus_service_device_real_retrieve_text_messages;
	iface->retrieve_text_messages_finish = dbus_service_device_real_retrieve_text_messages_finish;
	iface->send_text_message = (void (*)(FreeSmartphoneGSMSMS*, const gchar*, const gchar*, gboolean, gint*, gchar**, GError**)) dbus_service_device_real_send_text_message;
	iface->send_text_message_finish = dbus_service_device_real_send_text_message_finish;
}


static void dbus_service_device_free_smartphone_gsm_network_interface_init (FreeSmartphoneGSMNetworkIface * iface) {
	dbus_service_device_free_smartphone_gsm_network_parent_iface = g_type_interface_peek_parent (iface);
	iface->disable_call_forwarding = (void (*)(FreeSmartphoneGSMNetwork*, const gchar*, const gchar*, GError**)) dbus_service_device_real_disable_call_forwarding;
	iface->disable_call_forwarding_finish = dbus_service_device_real_disable_call_forwarding_finish;
	iface->enable_call_forwarding = (void (*)(FreeSmartphoneGSMNetwork*, const gchar*, const gchar*, const gchar*, gint, GError**)) dbus_service_device_real_enable_call_forwarding;
	iface->enable_call_forwarding_finish = dbus_service_device_real_enable_call_forwarding_finish;
	iface->get_call_forwarding = (GHashTable* (*)(FreeSmartphoneGSMNetwork*, const gchar*, GError**)) dbus_service_device_real_get_call_forwarding;
	iface->get_call_forwarding_finish = dbus_service_device_real_get_call_forwarding_finish;
	iface->get_calling_identification = (FreeSmartphoneGSMCallingIdentificationStatus (*)(FreeSmartphoneGSMNetwork*, GError**)) dbus_service_device_real_get_calling_identification;
	iface->get_calling_identification_finish = dbus_service_device_real_get_calling_identification_finish;
	iface->get_time_report = (void (*)(FreeSmartphoneGSMNetwork*, gint*, gint*, gint*, gint*, GError**)) dbus_service_device_real_get_time_report;
	iface->get_time_report_finish = dbus_service_device_real_get_time_report_finish;
	iface->get_signal_strength = (gint (*)(FreeSmartphoneGSMNetwork*, GError**)) dbus_service_device_real_get_signal_strength;
	iface->get_signal_strength_finish = dbus_service_device_real_get_signal_strength_finish;
	iface->get_status = (GHashTable* (*)(FreeSmartphoneGSMNetwork*, GError**)) dbus_service_device_real_get_status;
	iface->get_status_finish = dbus_service_device_real_get_status_finish;
	iface->list_providers = (FreeSmartphoneGSMNetworkProvider* (*)(FreeSmartphoneGSMNetwork*, int*, GError**)) dbus_service_device_real_list_providers;
	iface->list_providers_finish = dbus_service_device_real_list_providers_finish;
	iface->register_ = (void (*)(FreeSmartphoneGSMNetwork*, GError**)) dbus_service_device_real_register_;
	iface->register__finish = dbus_service_device_real_register__finish;
	iface->register_with_provider = (void (*)(FreeSmartphoneGSMNetwork*, const gchar*, GError**)) dbus_service_device_real_register_with_provider;
	iface->register_with_provider_finish = dbus_service_device_real_register_with_provider_finish;
	iface->send_ussd_request = (void (*)(FreeSmartphoneGSMNetwork*, const gchar*, GError**)) dbus_service_device_real_send_ussd_request;
	iface->send_ussd_request_finish = dbus_service_device_real_send_ussd_request_finish;
	iface->set_calling_identification = (void (*)(FreeSmartphoneGSMNetwork*, FreeSmartphoneGSMCallingIdentificationStatus, GError**)) dbus_service_device_real_set_calling_identification;
	iface->set_calling_identification_finish = dbus_service_device_real_set_calling_identification_finish;
	iface->unregister = (void (*)(FreeSmartphoneGSMNetwork*, GError**)) dbus_service_device_real_unregister;
	iface->unregister_finish = dbus_service_device_real_unregister_finish;
}


static void dbus_service_device_free_smartphone_gsm_call_interface_init (FreeSmartphoneGSMCallIface * iface) {
	dbus_service_device_free_smartphone_gsm_call_parent_iface = g_type_interface_peek_parent (iface);
	iface->activate = (void (*)(FreeSmartphoneGSMCall*, gint, GError**)) dbus_service_device_real_activate;
	iface->activate_finish = dbus_service_device_real_activate_finish;
	iface->activate_conference = (void (*)(FreeSmartphoneGSMCall*, gint, GError**)) dbus_service_device_real_activate_conference;
	iface->activate_conference_finish = dbus_service_device_real_activate_conference_finish;
	iface->emergency = (void (*)(FreeSmartphoneGSMCall*, const gchar*, GError**)) dbus_service_device_real_emergency;
	iface->emergency_finish = dbus_service_device_real_emergency_finish;
	iface->hold_active = (void (*)(FreeSmartphoneGSMCall*, GError**)) dbus_service_device_real_hold_active;
	iface->hold_active_finish = dbus_service_device_real_hold_active_finish;
	iface->initiate = (gint (*)(FreeSmartphoneGSMCall*, const gchar*, const gchar*, GError**)) dbus_service_device_real_initiate;
	iface->initiate_finish = dbus_service_device_real_initiate_finish;
	iface->join = (void (*)(FreeSmartphoneGSMCall*, GError**)) dbus_service_device_real_join;
	iface->join_finish = dbus_service_device_real_join_finish;
	iface->list_calls = (FreeSmartphoneGSMCallDetail* (*)(FreeSmartphoneGSMCall*, int*, GError**)) dbus_service_device_real_list_calls;
	iface->list_calls_finish = dbus_service_device_real_list_calls_finish;
	iface->release = (void (*)(FreeSmartphoneGSMCall*, gint, GError**)) dbus_service_device_real_release;
	iface->release_finish = dbus_service_device_real_release_finish;
	iface->release_all = (void (*)(FreeSmartphoneGSMCall*, GError**)) dbus_service_device_real_release_all;
	iface->release_all_finish = dbus_service_device_real_release_all_finish;
	iface->release_held = (void (*)(FreeSmartphoneGSMCall*, GError**)) dbus_service_device_real_release_held;
	iface->release_held_finish = dbus_service_device_real_release_held_finish;
	iface->send_dtmf = (void (*)(FreeSmartphoneGSMCall*, const gchar*, GError**)) dbus_service_device_real_send_dtmf;
	iface->send_dtmf_finish = dbus_service_device_real_send_dtmf_finish;
	iface->transfer = (void (*)(FreeSmartphoneGSMCall*, const gchar*, GError**)) dbus_service_device_real_transfer;
	iface->transfer_finish = dbus_service_device_real_transfer_finish;
}


static void dbus_service_device_free_smartphone_gsm_pdp_interface_init (FreeSmartphoneGSMPDPIface * iface) {
	dbus_service_device_free_smartphone_gsm_pdp_parent_iface = g_type_interface_peek_parent (iface);
	iface->activate_context = (void (*)(FreeSmartphoneGSMPDP*, GError**)) dbus_service_device_real_activate_context;
	iface->activate_context_finish = dbus_service_device_real_activate_context_finish;
	iface->deactivate_context = (void (*)(FreeSmartphoneGSMPDP*, GError**)) dbus_service_device_real_deactivate_context;
	iface->deactivate_context_finish = dbus_service_device_real_deactivate_context_finish;
	iface->get_context_status = (void (*)(FreeSmartphoneGSMPDP*, FreeSmartphoneGSMContextStatus*, GHashTable**, GError**)) dbus_service_device_real_get_context_status;
	iface->get_context_status_finish = dbus_service_device_real_get_context_status_finish;
	iface->get_credentials = (void (*)(FreeSmartphoneGSMPDP*, gchar**, gchar**, gchar**, GError**)) dbus_service_device_real_get_credentials;
	iface->get_credentials_finish = dbus_service_device_real_get_credentials_finish;
	iface->get_roaming_allowed = (gboolean (*)(FreeSmartphoneGSMPDP*, GError**)) dbus_service_device_real_get_roaming_allowed;
	iface->get_roaming_allowed_finish = dbus_service_device_real_get_roaming_allowed_finish;
	iface->set_roaming_allowed = (void (*)(FreeSmartphoneGSMPDP*, gboolean, GError**)) dbus_service_device_real_set_roaming_allowed;
	iface->set_roaming_allowed_finish = dbus_service_device_real_set_roaming_allowed_finish;
	iface->internal_status_update = (void (*)(FreeSmartphoneGSMPDP*, const gchar*, GHashTable*, GError**)) dbus_service_device_real_internal_status_update;
	iface->internal_status_update_finish = dbus_service_device_real_internal_status_update_finish;
	iface->set_credentials = (void (*)(FreeSmartphoneGSMPDP*, const gchar*, const gchar*, const gchar*, GError**)) dbus_service_device_real_set_credentials;
	iface->set_credentials_finish = dbus_service_device_real_set_credentials_finish;
}


static void dbus_service_device_free_smartphone_gsm_cb_interface_init (FreeSmartphoneGSMCBIface * iface) {
	dbus_service_device_free_smartphone_gsm_cb_parent_iface = g_type_interface_peek_parent (iface);
	iface->get_cell_broadcast_subscriptions = (gchar* (*)(FreeSmartphoneGSMCB*, GError**)) dbus_service_device_real_get_cell_broadcast_subscriptions;
	iface->get_cell_broadcast_subscriptions_finish = dbus_service_device_real_get_cell_broadcast_subscriptions_finish;
	iface->set_cell_broadcast_subscriptions = (void (*)(FreeSmartphoneGSMCB*, const gchar*, GError**)) dbus_service_device_real_set_cell_broadcast_subscriptions;
	iface->set_cell_broadcast_subscriptions_finish = dbus_service_device_real_set_cell_broadcast_subscriptions_finish;
}


static void dbus_service_device_free_smartphone_gsm_hz_interface_init (FreeSmartphoneGSMHZIface * iface) {
	dbus_service_device_free_smartphone_gsm_hz_parent_iface = g_type_interface_peek_parent (iface);
	iface->get_home_zone_status = (gchar* (*)(FreeSmartphoneGSMHZ*, GError**)) dbus_service_device_real_get_home_zone_status;
	iface->get_home_zone_status_finish = dbus_service_device_real_get_home_zone_status_finish;
	iface->get_known_home_zones = (gchar** (*)(FreeSmartphoneGSMHZ*, int*, GError**)) dbus_service_device_real_get_known_home_zones;
	iface->get_known_home_zones_finish = dbus_service_device_real_get_known_home_zones_finish;
}


static void dbus_service_device_free_smartphone_gsm_monitor_interface_init (FreeSmartphoneGSMMonitorIface * iface) {
	dbus_service_device_free_smartphone_gsm_monitor_parent_iface = g_type_interface_peek_parent (iface);
	iface->get_serving_cell_information = (GHashTable* (*)(FreeSmartphoneGSMMonitor*, GError**)) dbus_service_device_real_get_serving_cell_information;
	iface->get_serving_cell_information_finish = dbus_service_device_real_get_serving_cell_information_finish;
	iface->get_neighbour_cell_information = (GHashTable** (*)(FreeSmartphoneGSMMonitor*, int*, GError**)) dbus_service_device_real_get_neighbour_cell_information;
	iface->get_neighbour_cell_information_finish = dbus_service_device_real_get_neighbour_cell_information_finish;
}


static void dbus_service_device_free_smartphone_gsm_voice_mail_interface_init (FreeSmartphoneGSMVoiceMailIface * iface) {
	dbus_service_device_free_smartphone_gsm_voice_mail_parent_iface = g_type_interface_peek_parent (iface);
	iface->get_voice_mailbox_number = (gchar* (*)(FreeSmartphoneGSMVoiceMail*, GError**)) dbus_service_device_real_get_voice_mailbox_number;
	iface->get_voice_mailbox_number_finish = dbus_service_device_real_get_voice_mailbox_number_finish;
	iface->set_voice_mailbox_number = (void (*)(FreeSmartphoneGSMVoiceMail*, const gchar*, GError**)) dbus_service_device_real_set_voice_mailbox_number;
	iface->set_voice_mailbox_number_finish = dbus_service_device_real_set_voice_mailbox_number_finish;
	iface->get_stored_voice_mails = (gchar** (*)(FreeSmartphoneGSMVoiceMail*, int*, GError**)) dbus_service_device_real_get_stored_voice_mails;
	iface->get_stored_voice_mails_finish = dbus_service_device_real_get_stored_voice_mails_finish;
}


static void dbus_service_device_instance_init (DBusServiceDevice * self) {
}


static void dbus_service_device_finalize (GObject* obj) {
	DBusServiceDevice * self;
	self = DBUS_SERVICE_DEVICE (obj);
	G_OBJECT_CLASS (dbus_service_device_parent_class)->finalize (obj);
}


GType dbus_service_device_get_type (void) {
	return dbus_service_device_type_id;
}


GType dbus_service_device_register_type (GTypeModule * module) {
	static const GTypeInfo g_define_type_info = { sizeof (DBusServiceDeviceClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) dbus_service_device_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (DBusServiceDevice), 0, (GInstanceInitFunc) dbus_service_device_instance_init, NULL };
	static const GInterfaceInfo free_smartphone_info_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_info_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	static const GInterfaceInfo free_smartphone_device_realtime_clock_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_device_realtime_clock_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	static const GInterfaceInfo free_smartphone_device_power_supply_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_device_power_supply_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	static const GInterfaceInfo free_smartphone_gsm_debug_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_gsm_debug_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	static const GInterfaceInfo free_smartphone_gsm_device_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_gsm_device_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	static const GInterfaceInfo free_smartphone_gsm_sim_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_gsm_sim_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	static const GInterfaceInfo free_smartphone_gsm_sms_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_gsm_sms_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	static const GInterfaceInfo free_smartphone_gsm_network_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_gsm_network_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	static const GInterfaceInfo free_smartphone_gsm_call_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_gsm_call_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	static const GInterfaceInfo free_smartphone_gsm_pdp_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_gsm_pdp_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	static const GInterfaceInfo free_smartphone_gsm_cb_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_gsm_cb_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	static const GInterfaceInfo free_smartphone_gsm_hz_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_gsm_hz_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	static const GInterfaceInfo free_smartphone_gsm_monitor_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_gsm_monitor_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	static const GInterfaceInfo free_smartphone_gsm_voice_mail_info = { (GInterfaceInitFunc) dbus_service_device_free_smartphone_gsm_voice_mail_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	dbus_service_device_type_id = g_type_module_register_type (module, FSO_FRAMEWORK_TYPE_ABSTRACT_OBJECT, "DBusServiceDevice", &g_define_type_info, 0);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_TYPE_INFO, &free_smartphone_info_info);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_DEVICE_TYPE_REALTIME_CLOCK, &free_smartphone_device_realtime_clock_info);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_DEVICE_TYPE_POWER_SUPPLY, &free_smartphone_device_power_supply_info);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_GSM_TYPE_DEBUG, &free_smartphone_gsm_debug_info);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_GSM_TYPE_DEVICE, &free_smartphone_gsm_device_info);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_GSM_TYPE_SIM, &free_smartphone_gsm_sim_info);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_GSM_TYPE_SMS, &free_smartphone_gsm_sms_info);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_GSM_TYPE_NETWORK, &free_smartphone_gsm_network_info);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_GSM_TYPE_CALL, &free_smartphone_gsm_call_info);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_GSM_TYPE_PDP, &free_smartphone_gsm_pdp_info);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_GSM_TYPE_CB, &free_smartphone_gsm_cb_info);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_GSM_TYPE_HZ, &free_smartphone_gsm_hz_info);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_GSM_TYPE_MONITOR, &free_smartphone_gsm_monitor_info);
	g_type_module_add_interface (module, dbus_service_device_type_id, FREE_SMARTPHONE_GSM_TYPE_VOICE_MAIL, &free_smartphone_gsm_voice_mail_info);
	return dbus_service_device_type_id;
}


DBusServiceResource* dbus_service_resource_construct (GType object_type, FsoFrameworkSubsystem* subsystem) {
	DBusServiceResource * self = NULL;
	FsoFrameworkSubsystem* _tmp0_;
	g_return_val_if_fail (subsystem != NULL, NULL);
	_tmp0_ = subsystem;
	self = (DBusServiceResource*) fso_framework_abstract_dbus_resource_construct (object_type, "GSM", _tmp0_);
	return self;
}


DBusServiceResource* dbus_service_resource_new (FsoFrameworkSubsystem* subsystem) {
	return dbus_service_resource_construct (DBUS_SERVICE_TYPE_RESOURCE, subsystem);
}


static void dbus_service_resource_real_enableResource_data_free (gpointer _data) {
	dbus_service_resource_enableResourceData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (dbus_service_resource_enableResourceData, _data_);
}


static void dbus_service_resource_real_enableResource (FsoFrameworkAbstractDBusResource* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceResource * self;
	dbus_service_resource_enableResourceData* _data_;
	DBusServiceResource* _tmp0_;
	self = (DBusServiceResource*) base;
	_data_ = g_slice_new0 (dbus_service_resource_enableResourceData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_resource_real_enableResource);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_resource_real_enableResource_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_resource_real_enableResource_co (_data_);
}


static void dbus_service_resource_real_enableResource_finish (FsoFrameworkAbstractDBusResource* base, GAsyncResult* _res_, GError** error) {
	dbus_service_resource_enableResourceData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_resource_enableResource_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	dbus_service_resource_enableResourceData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_resource_real_enableResource_co (_data_);
}


static gboolean dbus_service_resource_real_enableResource_co (dbus_service_resource_enableResourceData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = ((FsoFrameworkAbstractObject*) _data_->self)->logger;
	fso_framework_logger_debug (_data_->_tmp0_, "Enabling GSM resource...");
	_data_->_tmp1_ = device;
	_data_->_state_ = 1;
	dbus_service_device_enable (_data_->_tmp1_, dbus_service_resource_enableResource_ready, _data_);
	return FALSE;
	_state_1:
	_data_->_tmp2_ = FALSE;
	_data_->_tmp2_ = dbus_service_device_enable_finish (_data_->_tmp1_, _data_->_res_);
	_data_->ok = _data_->_tmp2_;
	_data_->_tmp3_ = _data_->ok;
	if (!_data_->_tmp3_) {
		_data_->_tmp4_ = g_error_new_literal (FREE_SMARTPHONE_RESOURCE_ERROR, FREE_SMARTPHONE_RESOURCE_ERROR_UNABLE_TO_ENABLE, "Can't open the modem.");
		_data_->_inner_error_ = _data_->_tmp4_;
		if (_data_->_inner_error_->domain == FREE_SMARTPHONE_RESOURCE_ERROR) {
			g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
			g_error_free (_data_->_inner_error_);
			if (_data_->_state_ == 0) {
				g_simple_async_result_complete_in_idle (_data_->_async_result);
			} else {
				g_simple_async_result_complete (_data_->_async_result);
			}
			g_object_unref (_data_->_async_result);
			return FALSE;
		} else {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
			g_clear_error (&_data_->_inner_error_);
			return FALSE;
		}
	}
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_resource_real_disableResource_data_free (gpointer _data) {
	dbus_service_resource_disableResourceData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (dbus_service_resource_disableResourceData, _data_);
}


static void dbus_service_resource_real_disableResource (FsoFrameworkAbstractDBusResource* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceResource * self;
	dbus_service_resource_disableResourceData* _data_;
	DBusServiceResource* _tmp0_;
	self = (DBusServiceResource*) base;
	_data_ = g_slice_new0 (dbus_service_resource_disableResourceData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_resource_real_disableResource);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_resource_real_disableResource_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_resource_real_disableResource_co (_data_);
}


static void dbus_service_resource_real_disableResource_finish (FsoFrameworkAbstractDBusResource* base, GAsyncResult* _res_) {
	dbus_service_resource_disableResourceData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_resource_disableResource_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	dbus_service_resource_disableResourceData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_resource_real_disableResource_co (_data_);
}


static gboolean dbus_service_resource_real_disableResource_co (dbus_service_resource_disableResourceData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = ((FsoFrameworkAbstractObject*) _data_->self)->logger;
	fso_framework_logger_debug (_data_->_tmp0_, "Disabling GSM resource...");
	_data_->_tmp1_ = device;
	_data_->_state_ = 1;
	dbus_service_device_disable (_data_->_tmp1_, dbus_service_resource_disableResource_ready, _data_);
	return FALSE;
	_state_1:
	dbus_service_device_disable_finish (_data_->_tmp1_, _data_->_res_);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_resource_real_suspendResource_data_free (gpointer _data) {
	dbus_service_resource_suspendResourceData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (dbus_service_resource_suspendResourceData, _data_);
}


static void dbus_service_resource_real_suspendResource (FsoFrameworkAbstractDBusResource* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceResource * self;
	dbus_service_resource_suspendResourceData* _data_;
	DBusServiceResource* _tmp0_;
	self = (DBusServiceResource*) base;
	_data_ = g_slice_new0 (dbus_service_resource_suspendResourceData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_resource_real_suspendResource);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_resource_real_suspendResource_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_resource_real_suspendResource_co (_data_);
}


static void dbus_service_resource_real_suspendResource_finish (FsoFrameworkAbstractDBusResource* base, GAsyncResult* _res_) {
	dbus_service_resource_suspendResourceData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_resource_suspendResource_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	dbus_service_resource_suspendResourceData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_resource_real_suspendResource_co (_data_);
}


static gboolean dbus_service_resource_real_suspendResource_co (dbus_service_resource_suspendResourceData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = ((FsoFrameworkAbstractObject*) _data_->self)->logger;
	fso_framework_logger_debug (_data_->_tmp0_, "Suspending GSM resource...");
	_data_->_tmp1_ = device;
	_data_->_state_ = 1;
	dbus_service_device_suspend (_data_->_tmp1_, dbus_service_resource_suspendResource_ready, _data_);
	return FALSE;
	_state_1:
	dbus_service_device_suspend_finish (_data_->_tmp1_, _data_->_res_);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_resource_real_resumeResource_data_free (gpointer _data) {
	dbus_service_resource_resumeResourceData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (dbus_service_resource_resumeResourceData, _data_);
}


static void dbus_service_resource_real_resumeResource (FsoFrameworkAbstractDBusResource* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceResource * self;
	dbus_service_resource_resumeResourceData* _data_;
	DBusServiceResource* _tmp0_;
	self = (DBusServiceResource*) base;
	_data_ = g_slice_new0 (dbus_service_resource_resumeResourceData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_resource_real_resumeResource);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_resource_real_resumeResource_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_resource_real_resumeResource_co (_data_);
}


static void dbus_service_resource_real_resumeResource_finish (FsoFrameworkAbstractDBusResource* base, GAsyncResult* _res_) {
	dbus_service_resource_resumeResourceData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void dbus_service_resource_resumeResource_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	dbus_service_resource_resumeResourceData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	dbus_service_resource_real_resumeResource_co (_data_);
}


static gboolean dbus_service_resource_real_resumeResource_co (dbus_service_resource_resumeResourceData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = ((FsoFrameworkAbstractObject*) _data_->self)->logger;
	fso_framework_logger_debug (_data_->_tmp0_, "Resuming GSM resource...");
	_data_->_tmp1_ = device;
	_data_->_state_ = 1;
	dbus_service_device_resume (_data_->_tmp1_, dbus_service_resource_resumeResource_ready, _data_);
	return FALSE;
	_state_1:
	dbus_service_device_resume_finish (_data_->_tmp1_, _data_->_res_);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_resource_real_dependencies_data_free (gpointer _data) {
	DbusServiceResourceDependenciesData* _data_;
	_data_ = _data;
	_g_hash_table_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (DbusServiceResourceDependenciesData, _data_);
}


static void dbus_service_resource_real_dependencies (FsoFrameworkAbstractDBusResource* base, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBusServiceResource * self;
	DbusServiceResourceDependenciesData* _data_;
	DBusServiceResource* _tmp0_;
	self = (DBusServiceResource*) base;
	_data_ = g_slice_new0 (DbusServiceResourceDependenciesData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dbus_service_resource_real_dependencies);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dbus_service_resource_real_dependencies_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	dbus_service_resource_real_dependencies_co (_data_);
}


static GHashTable* dbus_service_resource_real_dependencies_finish (FsoFrameworkAbstractDBusResource* base, GAsyncResult* _res_) {
	GHashTable* result;
	DbusServiceResourceDependenciesData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static void _g_free0_ (gpointer var) {
	var = (g_free (var), NULL);
}


static void _g_variant_unref0_ (gpointer var) {
	(var == NULL) ? NULL : (var = (g_variant_unref (var), NULL));
}


static GVariant* _variant_new1 (const gchar* value) {
	return g_variant_ref_sink (g_variant_new_string (value));
}


static gboolean dbus_service_resource_real_dependencies_co (DbusServiceResourceDependenciesData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = g_str_hash;
	_data_->_tmp1_ = g_str_equal;
	_data_->_tmp2_ = g_hash_table_new_full (_data_->_tmp0_, _data_->_tmp1_, _g_free0_, _g_variant_unref0_);
	_data_->dependencies = _data_->_tmp2_;
	_data_->_tmp3_ = g_strdup ("");
	_data_->services = _data_->_tmp3_;
	_data_->first = TRUE;
	_data_->_tmp4_ = fso_gsm_theServiceDependencies;
	{
		_data_->service_collection = _data_->_tmp4_;
		_data_->service_it = NULL;
		for (_data_->service_it = _data_->service_collection; _data_->service_it != NULL; _data_->service_it = _data_->service_it->next) {
			_data_->_tmp5_ = g_strdup ((const gchar*) _data_->service_it->data);
			_data_->service = _data_->_tmp5_;
			{
				_data_->_tmp6_ = _data_->first;
				if (!_data_->_tmp6_) {
					_data_->_tmp7_ = _data_->services;
					_data_->_tmp8_ = g_strconcat (_data_->_tmp7_, ",", NULL);
					_g_free0 (_data_->services);
					_data_->services = _data_->_tmp8_;
				}
				_data_->_tmp9_ = _data_->services;
				_data_->_tmp10_ = _data_->service;
				_data_->_tmp11_ = g_strconcat (_data_->_tmp9_, _data_->_tmp10_, NULL);
				_g_free0 (_data_->services);
				_data_->services = _data_->_tmp11_;
				_data_->first = FALSE;
				_g_free0 (_data_->service);
			}
		}
	}
	_data_->_tmp12_ = _data_->dependencies;
	_data_->_tmp13_ = g_strdup ("services");
	_data_->_tmp14_ = _data_->services;
	_data_->_tmp15_ = _variant_new1 (_data_->_tmp14_);
	g_hash_table_insert (_data_->_tmp12_, _data_->_tmp13_, _data_->_tmp15_);
	_data_->result = _data_->dependencies;
	_g_free0 (_data_->services);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	_g_free0 (_data_->services);
	_g_hash_table_unref0 (_data_->dependencies);
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void dbus_service_resource_class_init (DBusServiceResourceClass * klass) {
	dbus_service_resource_parent_class = g_type_class_peek_parent (klass);
	FSO_FRAMEWORK_ABSTRACT_DBUS_RESOURCE_CLASS (klass)->enableResource = dbus_service_resource_real_enableResource;
	FSO_FRAMEWORK_ABSTRACT_DBUS_RESOURCE_CLASS (klass)->enableResource_finish = dbus_service_resource_real_enableResource_finish;
	FSO_FRAMEWORK_ABSTRACT_DBUS_RESOURCE_CLASS (klass)->disableResource = dbus_service_resource_real_disableResource;
	FSO_FRAMEWORK_ABSTRACT_DBUS_RESOURCE_CLASS (klass)->disableResource_finish = dbus_service_resource_real_disableResource_finish;
	FSO_FRAMEWORK_ABSTRACT_DBUS_RESOURCE_CLASS (klass)->suspendResource = dbus_service_resource_real_suspendResource;
	FSO_FRAMEWORK_ABSTRACT_DBUS_RESOURCE_CLASS (klass)->suspendResource_finish = dbus_service_resource_real_suspendResource_finish;
	FSO_FRAMEWORK_ABSTRACT_DBUS_RESOURCE_CLASS (klass)->resumeResource = dbus_service_resource_real_resumeResource;
	FSO_FRAMEWORK_ABSTRACT_DBUS_RESOURCE_CLASS (klass)->resumeResource_finish = dbus_service_resource_real_resumeResource_finish;
	FSO_FRAMEWORK_ABSTRACT_DBUS_RESOURCE_CLASS (klass)->dependencies = dbus_service_resource_real_dependencies;
	FSO_FRAMEWORK_ABSTRACT_DBUS_RESOURCE_CLASS (klass)->dependencies_finish = dbus_service_resource_real_dependencies_finish;
}


static void dbus_service_resource_instance_init (DBusServiceResource * self) {
}


/**
 * @class DBusService.Resource
 **/
GType dbus_service_resource_get_type (void) {
	return dbus_service_resource_type_id;
}


GType dbus_service_resource_register_type (GTypeModule * module) {
	static const GTypeInfo g_define_type_info = { sizeof (DBusServiceResourceClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) dbus_service_resource_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (DBusServiceResource), 0, (GInstanceInitFunc) dbus_service_resource_instance_init, NULL };
	dbus_service_resource_type_id = g_type_module_register_type (module, FSO_FRAMEWORK_TYPE_ABSTRACT_DBUS_RESOURCE, "DBusServiceResource", &g_define_type_info, 0);
	return dbus_service_resource_type_id;
}


/**
 * This function gets called on plugin initialization time.
 * @return the name of your plugin here
 * @note that it needs to be a name in the format <subsystem>.<plugin>
 * else your module will be unloaded immediately.
 **/
gchar* fso_factory_function (FsoFrameworkSubsystem* subsystem, GError** error) {
	gchar* result = NULL;
	FsoFrameworkSubsystem* _tmp0_;
	DBusServiceDevice* _tmp1_;
	GType _tmp2_;
	gchar* _tmp5_;
	g_return_val_if_fail (subsystem != NULL, NULL);
	_tmp0_ = subsystem;
	_tmp1_ = dbus_service_device_new (_tmp0_);
	_g_object_unref0 (device);
	device = _tmp1_;
	_tmp2_ = dbus_service_device_modemclass;
	if (_tmp2_ != G_TYPE_INVALID) {
		FsoFrameworkSubsystem* _tmp3_;
		DBusServiceResource* _tmp4_;
		_tmp3_ = subsystem;
		_tmp4_ = dbus_service_resource_new (_tmp3_);
		_g_object_unref0 (resource);
		resource = _tmp4_;
	}
	_tmp5_ = g_strdup (DBUS_SERVICE_MODULE_NAME);
	result = _tmp5_;
	return result;
}


/**
 * This function gets called on subsystem shutdown time.
 **/
void fso_shutdown_function (GError** error) {
	running = TRUE;
	async_helper (NULL, NULL);
	while (TRUE) {
		gboolean _tmp0_;
		GMainContext* _tmp1_ = NULL;
		_tmp0_ = running;
		if (!_tmp0_) {
			break;
		}
		_tmp1_ = g_main_context_default ();
		g_main_context_iteration (_tmp1_, TRUE);
	}
}


static void async_helper_data_free (gpointer _data) {
	AsyncHelperData* _data_;
	_data_ = _data;
	g_slice_free (AsyncHelperData, _data_);
}


void async_helper (GAsyncReadyCallback _callback_, gpointer _user_data_) {
	AsyncHelperData* _data_;
	_data_ = g_slice_new0 (AsyncHelperData);
	_data_->_async_result = g_simple_async_result_new (g_object_newv (G_TYPE_OBJECT, 0, NULL), _callback_, _user_data_, async_helper);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, async_helper_data_free);
	async_helper_co (_data_);
}


void async_helper_finish (GAsyncResult* _res_) {
	AsyncHelperData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static void async_helper_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
	AsyncHelperData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	async_helper_co (_data_);
}


static gboolean async_helper_co (AsyncHelperData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = resource;
	_data_->_state_ = 1;
	fso_framework_abstract_dbus_resource_disableResource ((FsoFrameworkAbstractDBusResource*) _data_->_tmp0_, async_helper_ready, _data_);
	return FALSE;
	_state_1:
	fso_framework_abstract_dbus_resource_disableResource_finish ((FsoFrameworkAbstractDBusResource*) _data_->_tmp0_, _data_->_res_);
	running = FALSE;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


/**
 * Module init function, DON'T REMOVE THIS!
 **/
void fso_register_function (GTypeModule* module) {
	FsoFrameworkLogger* _tmp0_;
	g_return_if_fail (module != NULL);
	dbus_service_device_register_type (module);
	dbus_service_resource_register_type (module);
	_tmp0_ = fso_framework_theLogger;
	fso_framework_logger_debug (_tmp0_, "fsogsm.dbus_service fso_register_function");
}


static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	if ((array != NULL) && (destroy_func != NULL)) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}


static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}



