This page is for developers using the Intel AppUp^TM Software Development Kit 0.8 Beta for MeeGo C/C++ Developers for Windows to develop C applications within a Microsoft* Windows* development environment and targeted for a MeeGo* runtime environment. The SDK (Software Development Kit) includes programming libraries, documentation, and sample code to help developers create, test, and submit C applications intended for distribution via the Intel AppUp center.

Note: This document covers C support only, even though the SDK also supports C ++. Information on C++ support is provided in separate documentation.

Intended Audience

This document is intended for experienced software developers who are developing applications for the Intel AppUp center. These can be new applications or existing ones, ported for the Intel AppUp center. This SDK supports development of C applications for MeeGo 1.1 with MeeGo 1.1 SDK for Windows. This SDK supports development in a Microsoft Windows 7* or Windows XP* 32-bit OS environment.

Both the MeeGo 1.1 SDK and the Intel AppUp SDK 0.8 Beta for MeeGo C/C++ Developers on Windows need to be installed.

Information about the specific editions and versions of the environments that are supported is provided in the SDK's Release Notes.

Using this API Reference

This API reference contains the following sections:

About this Document, introduces the contents and conventions of this document.
Application Reference Information, documents the SDK API Calls for applications. Code examples are provided, as appropriate.

Conventions and Symbols

The following table shows the conventions used in this document.

Conventions and Symbols Used in This Document

This type style	Indicates an element of syntax, reserved word, keyword, filename, computer output, or part of a program example. The text appears in lowercase unless uppercase is significant.
This type style	Indicates the exact characters you type as input. Also used to highlight the elements of a graphical user interface, such as buttons and menu names or filenames and labels when discussing program examples.
This type style	Indicates a placeholder for an identifier, an expression, a string, a symbol, or a value. Substitute actual item(s) for the placeholder.
Hyperlink	Indicates a hyperlink to internal or external information. Use CNTL+mouse click to navigate.
Notes, cautions, etc.	Note: Indicates an important comment or side topic for the user.

Related Information

Getting Started information for C and MeeGo is provided in the Intel AppUp Software Development Kit Developer Guide for MeeGo C Developers on Windows document, which is shipped with the Intel AppUp Software Development Kit for MeeGo C/C++ Developers on Windows. The SDK is available on the Intel AppUp Developer Program portal.

Application Reference Information

This section documents the SDK API Calls for Applications. The following subsections are provided:

Configuration and Build Information — Documents general configuration and build information needed to create applications.
Includes and Definitions — Documents Include and Definition requirements needed to create applications.
Application Initialization Call — Documents the API call to initialize the SDK library and the resources needed for applications.
Application Authorization Call — Documents the API call to determine if the application is authorized (or not authorized) to run.
Application Close Call — Documents the API call to release application resources and close the SDK library.
Instrumentation Calls — Documents the SDK library calls to implement Instrumentation (metering) of applications.
Custom Crash Reporting — Documents the method to implement custom Crash Reporting, when default Crash Reporting is not desired.
Return Codes — Documents the Return codes that are supported.
End User Error Messages — Documents the error messages that can be displayed to end users.

Configuration and Build Information

The following list provides basic configuration and build information needed to create applications:

Verify that the MeeGo 1.1 SDK is installed.
The Intel AppUp SDK library uses a default cdecl calling convention, even though no explicit _cdecl prefix appears for calls in the SDK headers, samples, and documents.
Verify that the Qt Creator project has statically linked the application to the SDK Library. The following lines must appear in the Qt Creator application project (.pro) files:

    LIBS += -lxml2\
                  -lpthread
    LIBS += “$$(IADP_SDK_DIR_MEEGO)Cpp\lib\libadpcore.a”\
                  “$$(IADP_SDK_DIR_MEEGO)Cpp\lib\libxerces-c.a”\
                  “$$(IADP_SDK_DIR_MEEGO)Cpp\lib\libxml-security-c.a”\
                  “$$(IADP_SDK_DIR_MEEGO)Cpp\lib\libcrypto.a”
IADP_SDK_DIR_MEEGO is the installation path of the SDK. The default path is Program Files/Intel/IntelAppUpSDKMeeGo/Cpp/lib/.

Includes and Definitions

The SDK library header, adpcore.h, must be included in the “#includes” area of your application, as shown below.

#include "adpcore.h"

The Authorized Application Debug ID, shown below, must also be defined. 128-bit number, expressed as a string using predefined constants. The value of the Authorized Application Debug ID is contained in the SDK library. You can also use the absolute value (all one’s), as shown in the sample. You must replace the Debug ID with a Production ID after testing. The Production ID is discussed in detail later in this section. There is also an Expired Application Debug ID to allow you to test the “expired” branch of your application.

// Debug application ID

const ADP_APPLICATIONID myApplicationID = (0x11111111, 0x11111111,

0x11111111, 0x11111111);

// API return code

ADP_RET_CODE ret_code;;

The SDK return code must be defined, as shown above.

Note that an Authorized Application Debug ID is used. During development, this Debug ID allows testing with the Intel AppUp Software Debugger. An alternate way to define the Authorized Application Debug ID is to reference the constant in the SDK library, as shown below:

// Debug application ID

const ADP_APPLICATIONID myApplicationID = (ADP_DEBUG_APPLICATIONID);

Application Initialization Call

The Application Initialization call, ADP_Initialize, initializes the SDK library and allocates the resources needed by the library. It also makes sure the version of the Intel AppUp center Consumer Client on the system is compatible with the SDK library version. ADP_Initialize should be inserted in the initialization section of the applications main routine. The call should be followed by an error handler.

Syntax

RETURN = ADP_Initialize();

Parameters

None.

Return Codes

Value	Meaning
ADP_SUCCESS	Operation was successful.
ADP_FAILURE	Operation was unsuccessful. It can also indicate that more than one instantiation of the application was attempted.
ADP_NOT_AVAILABLE	Operation failed because the SDK library was not available. This can occur if the Intel AppUp center software is not installed properly.
ADP_INCOMPATIBLE_VERSION	Operation failed because the API version of the application is not supported by the current Intel AppUp center software.
ADP_TIMEOUT	Operation failed because the connection between the SDK and the Intel AppUp center software timed out.

Notes

The SDK library must be included prior to invoking this call.
The return code must be defined prior to invoking this call.

Code Example

The following example shows the use of the ADP_Initialize call. A basic exception handler is used.

// Initialize the SDK library, and determine whether the system

// is compatible. It must be called before using any other SDK call.

ret_code = ADP_Initialize();

if (ret_code != ADP_SUCCESS)

{

qDebug("FAIL: ADP_Initialize failed with error code; %i\n", ret_code);

exit (1);

}

Application Authorization Call

The Application Authorization call, ADP_IsAuthorized, authorizes the application via the Intel AppUp center. The return code indicates authorization status or errors. ADP_IsAuthorized should be inserted in the initialization section of the applications main routine. The call should be followed by an error handler.

Syntax

RETURN = ADP_IsAuthorized(ApplicationID);

Parameters

ApplicationID: Application GUID in string or integer format. The data type of the GUID is four unsigned, long integers, as follows:

ApplicationID(unsigned long l1, unsigned long l2, unsigned long l3, unsigned long l4)

See the Application IDs discussion later.

Return Codes

Value	Meaning
ADP_FAILURE	Operation was unsuccessful. It can also indicate that more than one instantiation of the application was attempted.
ADP_NOT_AVAILABLE	Operation failed because the SDK library was not available. This can occur if the Intel AppUp center software is not installed properly.
ADP_NOT_INITIALIZED	Operation failed because the SDK library is not initialized. Any API call made prior to initialization causes this code to be generated.
ADP_AUTHORIZED	The application is authorized to run.
ADP_NOT_AUTHORIZED	The application is not authorized to run. Applications can choose how to respond, such as preventing an application from running, allowing the application to run for a grace period so the user can obtain a license, allowing the application to run with limited functionality, etc.
ADP_AUTHORIZATION_EXPIRED	The application’s license has expired. Applications can choose how to respond, such as preventing an application from running, allowing the application to run for a grace period so the user can obtain a license, allowing the application to run with limited functionality, etc.
ADP_TIMEOUT	Operation failed because the connection between the SDK and the Intel AppUp center software timed out.

Application IDs

The Application ID is a unique identifier for Intel AppUp Developer Program applications. There are two types of application GUIDs: (1) a Debug Application ID, and (2) a Production Application ID. Debug Application IDs are used for testing applications. You must replace the Debug Application ID with a Production Application ID after testing to upload your application to the Intel AppUp Developer Program portal.

Debug Application ID — During development, the Application Debug ID allows testing with the Intel AppUp Software Debugger. This Debug ID is a 128-bit number, expressed as a string using predefined constants. Two versions of a Debug ID exist:

ADP_DEBUG_APPLICATIONID: Used with the Intel AppUp Software Debugger to get an ADP_AUTHORIZED response back. This allows most of the application to be tested and debugged. The value of this Debug ID is all ones.
ADP_EXPIRED_APPLICATIONID: Used with the Intel AppUp Software Debugger to get an ADP_AUTHORIZATION_EXPIRED response back. This allows the “expired” branch of the application to be tested and debugged. The value of this Debug ID is all zeroes.

Production Application ID — Production IDs are obtained from the Intel AppUp Developer Program portal, which requires that you enroll in the Intel AppUp Developer Program. The Production ID is a 128-bit number organized as four integers in hex format.

Notes

A successful ADP_Initialize call must be completed before invoking this call.
A sensible approach to handling an ADP_TIMEOUT error during the first authorization attempt is to attempt authorization again.
Multiple Application Constructor calls can be made, but the Application ID from the first call is the only one used in the application (such as, in a crash report).

Code Example

// Check the application is authorized to run.

ret_code = ADP_IsAuthorized(ADP_DEBUG_APPLICATIONID);

// TODO: Application specific stuff goes here

if( ret_code == ADP_AUTHORIZED )

{

qDebug( "Hello World \n" );

}

else

{

qDebug( "Not authorized to run \n" );

exit (1);

}

// Application code goes here

Application Close Call

On application or process exit, the SDK library must be instructed to release the object and close the SDK library. The ADP_Close call performs these tasks. ADP_Close should be inserted in the shutdown section of the applications main routine. The call should be followed by an error handler.

Syntax

RETURN = ADP_Close();

Parameters

None.

Return Codes

Value	Meaning
ADP_SUCCESS	Operation was successful.
ADP_FAILURE	Operation was unsuccessful. It can also indicate that more than one instantiation of the application was attempted.

Notes

None at present.

Code Example

The following example shows the use of the ADP_Close call. A basic error handler is used.

// Cleanup the SDK data structure, and shutdown connections used by the SDK.

ret_code = ADP_Close();

if( ret_code != ADP_SUCCESS )

{

qDebug("FAIL: ADP_Close failed with error code %i\n", ret_code);

}

return 0;

Instrumentation

The SDK supports the following Instrumentation events to measure application usage:

Application Begin Event – Triggers sending a Begin Event message to the Intel AppUp center for the application.
Application End Event – Triggers sending an End Event message to the Intel AppUp center for the application.

A usage record is only generated when a Begin Event is followed eventually by an End Event. A Begin Event alone does not cause a usage record to be generated.

Begin Event Call

It is recommended that you insert the ADP_ApplicationBeginEvent call immediately after the application authorization call. This starts usage measurement when the application is first authorized.

Syntax

RETURN = ADP_ApplicationBeginEvent();

Parameters

None.

Return Codes

Value	Meaning
ADP_SUCCESS	Operation was successful.
ADP_FAILURE	Operation was unsuccessful. It can also indicate that more than one instantiation of the application was attempted.
ADP_NOT_AVAILABLE	Operation failed because the SDK library was not available. This can occur if the Intel AppUp center software is not installed properly.
ADP_NOT_INITIALIZED	Operation failed because the SDK library is not initialized. Any API call made prior to initialization causes this code to be generated.
ADP_NOT_AUTHORIZED	The application is not authorized to run. Applications can choose how to respond, such as preventing an application from running, allowing the application to run for a grace period so the user can obtain a license, allowing the application to run with limited functionality, etc.
ADP_TIMEOUT	Operation failed because the connection between the SDK library and the Intel AppUp center software timed out.

Notes

An ADP_BeginEvent call must be preceded by a successful ADP_IsAuthorized call or an error is returned.

Code Example

The following example shows the use of the ADP_ApplicationBeginEvent call to trigger a Begin Event message. The error handler is assumed.

{

// Initialize and Authorize Application;

// Record Application Start

if (( ret_code = ADP_ApplicationBeginEvent())!= ADP_SUCCESS) {

// handle error conditions

}

// Application code goes here

}

End Event Call

End Events must be preceded by Begin Events or a warning code is returned. The ADP_ApplicationEndEvent call is typically used as part of the application shutdown sequence.

Syntax

RETURN = ADP_ApplicationEndEvent();

Parameters

None.

Return Codes

Value	Meaning
ADP_SUCCESS	Operation was successful.
ADP_FAILURE	Operation was unsuccessful. It can also indicate that more than one instantiation of the application was attempted.
ADP_NOT_AVAILABLE	Operation failed because the SDK library was not available. This can occur if the Intel AppUp center software is not installed properly.
ADP_NOT_INITIALIZED	Operation failed because the SDK library is not initialized. Any API call made prior to initialization causes this code to be generated.
ADP_NOT_AUTHORIZED	The application is not authorized to run. Applications can choose how to respond, such as preventing an application from running, allowing the application to run for a grace period so the user can obtain a license, allowing the application to run with limited functionality, etc.
ADP_NO_APP_BEGIN_EVENT	Operation failed because an End Event has been attempted with no prior Begin Event. A Begin Event call must precede an End Event call in the application.
ADP_TIMEOUT	Operation failed because the connection between the SDK library and the Intel AppUp center software timed out.

Notes

A successful ADP_ApplicationBeginEvent call must have been previously completed or the ADP_NO_APP_BEGIN_EVENT warning code is returned.
A sensible approach to handing the first occurrence of an ADP_FAILURE return code (in critical situations) is to attempt the authorization sequence. This may re-establish a valid session with the Intel AppUp center software.

Code Example

The following example shows the use of the ADP_ApplicationEndEvent call to trigger an End Event message. The error handler is assumed.

{

// Application code goes here

// Record Application End

if (( ret_code = ADP_ApplicationEndEvent())!= ADP_SUCCESS) {

// handle error and warning conditions

}

// Application code goes here

}

Crash Reporting

The SDK supports Crash Reporting to provide a snapshot of the state of the application when it does crash. Default Crash Reporting is implemented using a pre-defined SDK library routine. Custom Crash Reporting can be implemented by changing elements of the pre-defined routine.

Note: For C, no integrated error handling/crash reporting is provided (other SDK, such as the C++, .NET, and Java SDKs, support a more integrated approach).

For default Crash Reporting, all information in the report is pre-defined by the SDK library code. Default crash reports are viewable via My Dashboard on the Intel AppUp Developer Program portal. This information includes application context information, runtime environment information, SDK identification information, and a core stack dump. You can view the complete report by clicking on the Details link for a specific report. The Intel AppUp Software Development Kit Developer Guide for C and MeeGo provides more information on My Dashboard and how Crash Reporting works at the client system level.

ADP_ReportCrash

The ADP_ReportCrash call is used by an application to report a crash. The Intel AppUp center Consumer Client Services is responsible for delivering the report and dump information to the Intel AppUp Developer Program portal. Refer to the syntax information below for implementation details.

Syntax

typedef struct {

wchar_t *name;

wchar_t *value;

} ADP_CrashReportField;

RETURN ADP_ReportCrash(

const wchar_t *Module,

unsigned long LineNumber,

const wchar_t *Message,

const wchar_t *Category,

const wchar_t *ErrorData,

unsigned long ErrorDataSize,

ADP_CrashReportField *CustomFields,

unsigned long CustomFieldNumber

);

Parameters

Module [in, required]

The name of the application module where the error/crash occurred. Must not exceed 80 characters.

LineNumber [in, required]

The line number where the error/crash occurred.

Message [in, required]

A short message describing the error/crash or some basic information. Must not exceed 80 characters.

Category [in, required]

A text field that can be used for sorting and grouping crash reports in the Developer Dashboard. Must not exceed 80 characters.

ErrorData [in, optional]

The detailed error data in text format to be attached to the crash record.

ErrorDataSize [in, required if ErrorData is provided]

The size of data to be attached to the crash record. Must not exceed 4000 characters.

CustomFields [in, optional]

The customized data field to be attached to the crash record, in the format of ADP_CrashReportField. Name and value fields must not exceed 80 characters each.

CustomFieldNumber [in, required if CustomFields is provided]. Must not exceed 20.

The number of customized data fields to be attached to the crash record. Must not exceed 20.

Return Codes

Value	Meaning
ADP_SUCCESS	Operation was successful.
ADP_FAILURE	Operation was unsuccessful. It can also indicate that more than one instantiation of the application was attempted.
ADP_NOT_AVAILABLE	Operation failed because the SDK library was not available. This can occur if the Intel AppUp center software is not installed properly.
ADP_NOT_INITIALIZED	Operation failed because the SDK library is not initialized. Any API call made prior to initialization causes this code to be generated.
ADP_NOT_AUTHORIZED	The application is not authorized to run. Applications can choose how to respond, such as preventing an application from running, allowing the application to run for a grace period so the user can obtain a license, allowing the application to run with limited functionality, etc.
ADP_TIMEOUT	Operation failed because the connection between the SDK library and the Intel AppUp center software timed out.

Custom Crash Reporting

The table below lists the possible fields in a crash report, with the Source column defining the source (SDK or Developer) of the information for the respective field. As a developer, you can modify the fields where the Source is listed as Developer. Fields are modified by overriding the default field.

Note: It is your responsibility to make sure that custom Crash Reports do not include any data that violates Intel Privacy rules. See http://appdeveloper.intel.com for details.

Custom Crash Report Fields and Sources

Crash Report Fields	My Dashboard Column	Source
Application Name	No (but included in Details)	SDK
Application ID	No (but included in Details)	SDK
ModuleName	Module (and in Details)	Developer
LineNumber	Line (and in Details)	Developer
Category	No (but included in Details)	Developer
Message	Messages (and in Details)	Developer
ErrorData	No (but included in Details)	Developer
SDK API Level	No (but included in Details)	SDK
Runtime	Runtime (and in Details)	SDK
Runtime version	No (but included in Details)	SDK
OS	OS (and in Details)	SDK
OS version	No (but included in Details)	SDK
Timestamp	Timestamp (and in Details)	SDK
Up to 20 custom fields	(reserved for future use)	Developer

The fields with the greatest flexibility for customization are listed below:

The Category field allows you to create categories to sort your crash reports on the Intel AppUp Developer Program portal. For example, you may wish to create categories called “MEMORY”, “IO”, “USER ERROR”, etc.
The Error Data field allows you to create your own stack dumps or long error messages, to help you understand why your application crashed.

Note: Some crashes can lead to a client system eventually halting. In these cases, the time to store a crash report on the client system may be limited. To maximize obtaining crash information, you should consider the tradeoffs between the amount of information to include in a custom crash report, versus a potentially narrow window of time to store the information on the client system.

Return Codes

The following table is a comprehensive list of the return/error codes returned by SDK API calls to the calling routine, along with description of possible conditions that caused each code to be returned. Not every result code is returned for every API call. Refer to the information for a specific API call to see what codes may be returned for that call. (The information on a specific API call also may contain additional details on specific conditions that may cause a code to be returned for that call.) The table groups return codes into the following categories: Success, Authorization Status, Error, and Warning.

API Call Return Codes

Success
Value	Meaning
ADP_SUCCESS	Operation was successful.
Authorization Status
Value	Meaning
ADP_AUTHORIZED	The application is authorized to run.
ADP_NOT_AUTHORIZED	The application is not authorized to run. Applications can choose how to respond, such as preventing an application from running, allowing the application to run for a grace period, so the user can obtain a license, allowing the application to run with limited functionality, etc.
ADP_AUTHORIZATION_EXPIRED	The application’s license has expired. Applications can choose how to respond, such as preventing an application from running, allowing the application to run for a grace period so the user can obtain a license, or allowing the application to run with limited functionality, etc.
Error
Value	Meaning
ADP_NOT_AVAILABLE	Operation failed because the SDK library was not available. This can occur if the Intel AppUp center software is not installed properly.
ADP_NOT_INITIALIZED	Operation failed because the SDK library is not initialized. Any API call made prior to initialization causes this code to be generated.
ADP_INCOMPATIBLE_VERSION	Operation failed because the API version of the application is not supported by the current Intel AppUp center software.
ADP_TIMEOUT	Operation failed because the connection between the SDK library and the Intel AppUp center software timed out.
ADP_FAILURE	Operation was unsuccessful.
Warning
Value	Meaning
ADP_NO_APP_BEGIN_EVENT	Operation failed because an End Event has been attempted with no prior Begin Event. A Begin Event call must precede an End Event call in the application.

Code Example

The following code sample shows a switch case routine for handling errors after the ADP_Initialize call. Variations of this routine can be used to handle errors and warnings for the other calls.

if ((ret_code = ADP_Initialize()) != ADP_SUCCESS ){

switch( ret_code ) {

case ADP_INCOMPATIBLE_VERSION:

qDebug( "ERROR: Incompatible version" );

break;

case ADP_NOT_AVAILABLE:

qDebug("ERROR: Intel AppUp(SM) center client not running" );

break;

case ADP_TIMEOUT:

default:

qDebug("ERROR: Timeout error" );

break;

case ADP_FAILURE:

default:

qDebug("ERROR: Unknown error" );

break;

} // switch

exit( -1 );

} // if-then

End User Error Messages

The SDK contains error message strings that can be retrieved by applications and displayed to end users. These messages are accessed via their unique Message ID. They do not map directly to the Return Codes.

End User Error Messages

Message ID	Message Text
String_ADP_AUTHORIZATION_EXPIRED	The license for this application has expired.
String_ADP_BEGINEVENT_ERROMSG	The application experienced an error while starting a usage record.
String_ADP_ENDEVENT_ERRORMSG	The application experienced an error while ending a usage record.
String_ADP_FAILURE	The application experienced a critical error.
String_ADP_INCOMPATIBLE_VERSION	The current Intel AppUp center software does not support this version of the application.
String_ADP_NO_APP_BEGIN_EVENT	The application did not complete a start of usage record.
String_ADP_NOT_AUTHORIZED	The application is not authorized to run under this account on this device.
String_ADP_NOT_AVAILABLE	The application cannot connect to the Intel AppUp center.
String_ADP_NOT_INITIALIZED	The application did not initialize properly.
String_ADP_TIMEOUT	The Intel AppUp center response timed out.

Revision History

Document Number	Revision Number	Description	Revision Date
324698	001	Initial C language document release to support SDK 0.8 Beta for MeeGo C/C++.	January 2011

Disclaimer and Legal Information

INFORMATION IN THIS DOCUMENT IS PROVIDED IN CONNECTION WITH INTEL(R) PRODUCTS. NO LICENSE, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, TO ANY INTELLECTUAL PROPERTY RIGHTS IS GRANTED BY THIS DOCUMENT. EXCEPT AS PROVIDED IN INTEL'S TERMS AND CONDITIONS OF SALE FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSOEVER, AND INTEL DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT.
UNLESS OTHERWISE AGREED IN WRITING BY INTEL, THE INTEL PRODUCTS ARE NOT DESIGNED NOR INTENDED FOR ANY APPLICATION IN WHICH THE FAILURE OF THE INTEL PRODUCT COULD CREATE A SITUATION WHERE PERSONAL INJURY OR DEATH MAY OCCUR.
Intel may make changes to specifications and product descriptions at any time, without notice. Designers must not rely on the absence or characteristics of any features or instructions marked "reserved" or "undefined." Intel reserves these for future definition and shall have no responsibility whatsoever for conflicts or incompatibilities arising from future changes to them. The information here is subject to change without notice. Do not finalize a design with this information.
The products described in this document may contain design defects or errors known as errata which may cause the product to deviate from published specifications. Current characterized errata are available on request.
Contact your local Intel sales office or your distributor to obtain the latest specifications and before placing your product order.
Copies of documents which have an order number and are referenced in this document, or other Intel literature, may be obtained by calling 1-800-548-4725, or by visiting Intel's Web Site.

Intel processor numbers are not a measure of performance. Processor numbers differentiate features within each processor family, not across different processor families. See http://www.intel.com/products/processor_number for details.

For beta and pre-release product versions. This document contains information on products in the design phase of development.

BunnyPeople, Celeron, Celeron Inside, Centrino, Centrino Atom, Centrino Atom Inside, Centrino Inside, Centrino logo, Core Inside, FlashFile, i960, InstantIP, Intel, Intel logo, Intel386, Intel486, IntelDX2, IntelDX4, IntelSX2, Intel Atom, Intel Atom Inside, Intel Core, Intel Inside, Intel Inside logo, Intel. Leap ahead., Intel. Leap ahead. logo, Intel NetBurst, Intel NetMerge, Intel NetStructure, Intel SingleDriver, Intel SpeedStep, Intel StrataFlash, Intel Viiv, Intel vPro, Intel XScale, Itanium, Itanium Inside, MCS, MMX, Oplus, OverDrive, PDCharm, Pentium, Pentium Inside, skoool, Sound Mark, The Journey Inside, Viiv Inside, vPro Inside, VTune, Xeon, and Xeon Inside are trademarks of Intel Corporation in the U.S. and other countries.

*Other names and brands may be claimed as the property of others.

Microsoft product screen shot(s) reprinted with permission from Microsoft Corporation.

Average:

Average: 5 (1 vote)

Tags:

Intel AppUp^SM developer program

Intel AppUp Software Development Kit API Reference for MeeGo C Developers on Windows

About this Document

Intended Audience

Using this API Reference

Conventions and Symbols

Related Information

Application Reference Information

Configuration and Build Information

Includes and Definitions

Application Initialization Call

Code Example

Application Authorization Call

Code Example

Application Close Call

Code Example

Instrumentation

Begin Event Call

Code Example

End Event Call

Code Example

Crash Reporting

ADP_ReportCrash

Custom Crash Reporting

Return Codes

Code Example

End User Error Messages

Revision History

Disclaimer and Legal Information

KEY ACTIONS

DEVELOPMENT PLATFORMS

HOME

DEVELOPMENT

SDK & TOOLS

DOCUMENTATION

OPPORTUNITIES

COMMUNITY

SUPPORT

FOLLOW US ON

Intel AppUpSM developer program

Intel AppUp Software Development Kit API Reference for MeeGo C Developers on Windows

About this Document

Intended Audience

Using this API Reference

Conventions and Symbols

Related Information

Application Reference Information

Configuration and Build Information

Includes and Definitions

Application Initialization Call

Code Example

Application Authorization Call

Code Example

Application Close Call

Code Example

Instrumentation

Begin Event Call

Code Example

End Event Call

Code Example

Crash Reporting

ADP_ReportCrash

Custom Crash Reporting

Return Codes

Code Example

End User Error Messages

Revision History

Disclaimer and Legal Information

KEY ACTIONS

DEVELOPMENT PLATFORMS

HOME

DEVELOPMENT

SDK & TOOLS

DOCUMENTATION

OPPORTUNITIES

COMMUNITY

SUPPORT

FOLLOW US ON

Intel AppUp^SM developer program