1GLOBAL Connect API (2024-10-17)

Secure by Design

1GLOBAL strives to implement best of breed security controls to its products and services. 1GLOBAL Connect API has considered security by design since it’s conception. This ensures that all layers from servers to data and source code follow a security by design approach.

1GLOBAL ensures all servers running Connect have a secure architecture and are securely hardened with configurations aligned with international and recognized standards.

Additionally, 1GLOBAL implements a strict vulnerability management program that continuously monitors for potential attack vectors along with the execution of periodic penetration tests to test our defences.

Knowing that preventive controls are just a part of the security puzzle, 1GLOBAL also operates a continuous monitoring and security incident response capability, within from our Cyber Defence Centre.

To maintain a high level of service for all clients of the platform, we enforce rate limiting on our APIs. These limits are applied based on the authentication credentials being used.

By default, the Connect API allows up to 1,000 requests per minute per resource endpoint, which should be sufficient for most high-traffic applications. We monitor the request volume for each API client and apply throttling if the allowed limit is exceeded.

Depending on your requirements, we may adjust this limit or establish different limits for certain API calls. If the current rate limits do not meet your needs, please contact Service Desk to request an increase.

To prevent your systems from becoming unavailable, we strongly recommend implementing custom logic to handle the rate limiting quotas. For every API request that stays within the current rate limits, you will receive a response with the following HTTP headers:

If you exceed the rate limit quota, you will receive a 429 Too Many Requests error, indicating that you have sent too many requests within the quota period.

Example:

{
    "message": "Rate limit exceeded ! You reach the limit of 10 requests per 1 minutes",
    "http_status_code": 429
}

Currency amounts

Connect API will always send and receive currency in the smallest unit the currency allows. In practice, this means we will receive amounts in whole units, not decimals.

The specific unit used for currency in the API depends on whether it is a zero-decimal currency.

• Zero-decimal currencies: For currencies that do not have decimal subunits, such as the Japanese Yen (JPY), the amount should be provided in the major unit of the currency. The major unit corresponds to the ISO 4217 code of the currency. For example, to specify an amount of JPY 15, set the amount as 15.

• Other currencies: For currencies that do have decimal subunits, Connect API supports values up to two decimal places in the major unit of the currency. This value must be converted to an integer by multiplying it by 100. For example, an amount of $3.53 should be provided as 3.53 x 100, which is 353.

We adhere to industry-standard conventions, allowing you to use familiar tools seamlessly. Our APIs are designed for self-service, guiding you through the next steps with ease. They are intuitive, well-documented, and backed by certifications to support smooth and secure integration.

To further enhance usability, we maintain consistent language across all services. This ensures a seamless experience, allowing you to quickly navigate and integrate different APIs without having to adapt to new terminology or conventions. The result is improved learnability, faster integration, and greater efficiency.

HAL standardizes the format of API resources and links, making it easier to navigate and interact with our APIs. By providing a consistent approach to hyperlinking between API resources, HAL allows seamless integration between different APIs, offering a more consumable and explorable experience.

One of HAL’s key advantages is that it is both machine-readable and human-readable, enabling you to quickly grasp the context from the API reference documentation.

We adopt this convention to structure resource and action links, ensuring compatibility with standard libraries for smoother and more efficient development.

{
  ...
 "_links": {
    "self": {
      "href": "https://example.com/probs/1234"
    },
    "author": {
      "href": "https://example.com/users/john"
    }
  }
}

To protect the service against overload, as well as to support client side iteration and batch processing experience, resource listing endpoints implement cursor-based pagination.

The only input required is the page size (using limit parameter) and subsequent navigation can be done through the next/prev page links provided in each page's response payload.

To prevent misuse of the pagination feature, each API defines a maximum allowed page size (currently 40).

{
  ...
  "_links": {
    "self": { "href": "https://example.com/probs?limit=10" },
    "prev": { "href": "https://example.com/probs?cursor=MTY3NjE1ODU1MS8yNUMxOTgxRjA1RDU5MDAwMDAwMA%3D%3D&limit=10" },
    "next": { "href": "https://example.com/probs?cursor=MTY3NjEzMzkxMS8yNUMxMEYzNkJBODA1NTkwMDAwMDAw&limit=10" },
  }
}

• Correlation-ID: In order to easily identify a request on all of 1GLOBAL's subsystems, we require that requesters create a unique identifier that will be sent on every request header when (Correlation-Id) using the api. This way we can easily identify a request or a sequence of events between both 1GLOBAL and the requester.

1GLOBAL strives to maintain backward compatibility across its APIs to provide a consistent experience for clients. However, there are instances where introducing breaking changes becomes necessary to implement new features, improvements, compliance reasons or architectural updates, in that cases, a new version of the API will be made available. We follow a Header Versioning approach, combined with data-based versioning, to ensure that clients can smoothly transition to the updated version without disrupting their current integrations. Clear documentation, migration guides, and deprecation timelines will always accompany these changes to minimize any potential impact.

Any additive (non-breaking) changes will be incorporated into all supported API versions, ensuring compatibility while providing access to new features.

Non Breaking Change definition

• Changing the lengh or format of identifiers including changing or removing prefixes
• Adding new optional request parameters to existing APIs
• Adding new properties to existing API responses
• Adding new HTTP headers ( optional request and response )
• Increasing the lenght of existing string field values
• New enumerate values
• New error codes
• Changing error messages
• Adding new webhooks event types (you might need to explicitly opt into these)
• Adding new properties to existing webhook event schemas
• New links and relationship types
• Changing FQDNs/path in links
• Reordering elements

Connect API follows standard HTTP status codes to communicate error information in a consistent and compliant manner following RFC7807

• HTTP status codes will be 4xx or 5xx when there's a problem
• The body of the response will be a JSON object
• The errors property contains an array giving specific details of one or more errors that occurred.

Status codes in the 4xx range

These status codes indicate an issue with the request that needs to be resolved. Once the issue is fixed, you can safely retry the call. Common examples include authentication errors (HTTP status code 401) or request body validation errors (HTTP status code 400).

Status codes in the 5xx range

These errors typically indicate server-side issues, ranging from configuration problems (which may be specific to a merchant or entity) to internal network connectivity issues. They can be transient, affecting only a single call, or persistent, impacting multiple calls over an extended period. In most cases, callers will be unable to resolve these issues on their own. The most common example of 5xx errors is timeouts.

{
    "title": "Invalid request parameters",
    "status": 400,
    "detail": "Invalid request parameters",
    "errors": [
        {
            "code": "MISSING_CONDITIONAL_MANDATORY_FIELD",
            "detail": "Field(s) [first_name, last_name, email, address] cannot be null when field [id] is equal to [null]",
            "json_path": "$.subscriber.id"
        },
        {
            "code": "GENERIC_ERROR",
            "detail": "must not be empty",
            "json_path": "$.purchase_location"
        }
    ],
    "correlation_id": "daaccc90-dd03-471c-a892-0e8c5ec27026"
}

Canada

United States

"Lifecycle" refers to the series of stages or states that an entity (such as an order or product) goes through from its creation to its completion or termination. It represents the entire journey of the entity within the system, including all possible states and transitions.

Product Lifecycle Flow Description

This diagram provides an overview of the product lifecycle, detailing the various states and transitions a product can undergo, depending on user actions, scheduled product events, and network-triggered occurrences.

Key Lifecycle Stages:

1. Start:

   • This is the initial state of the product, where it can either proceed to a Active (immediate activation mode ), scheduled activation or await first-time usage.

2. Scheduled:

   • At this stage, the product is set to activate at a future time or upon a certain event.
   • User Actions:
     • The partner can choose to "Activate Now," immediately moving the product to the Active state.
     • Alternatively, the partner can cancel the scheduled activation, leading to the Canceled state.
   • Scheduled Activation: If no manual action is taken, the product will automatically become Active based on the pre-defined schedule.

3. Pending First Usage:

   • The product is awaiting its first usage before becoming active.
   • User Actions:
     • The partner can manually activate the product, moving it to the Active state.
     • They also have the option to cancel the product, transitioning it to the Canceled state.
   • Product Actions:
     • If the product is not used within a specified time window, it will move to the Expired state.

4. Active:

   • This state signifies that the product is actively being used or is ready for use.
   • Product Exhaustion: When the product’s capacity is fully consumed, it will transition to the Depleted state.
   • Product End: If the product reaches its scheduled end, it will move to the Terminated state.
   • Cancellation: The partner can also choose to manually cancel the product, transitioning it to the Canceled state.

5. Depleted:

   • This state indicates that the product has been fully utilized and is no longer available for further use.

6. Terminated:

   • The product has reached the end of its validity.

7. Canceled:

   • The partner or system has canceled the product, stopping any further action and ending its lifecycle.

8. Expired:

   • The product has not been used within the defined period and has expired, making it unavailable for activation or use.

Color Legend:

• Black (User Action/API): These arrows represent actions taken by the partner, such as activating, canceling, or using the product.
• Blue (Product Actions): These arrows depict automatic transitions triggered by the product’s schedule, like activation, expiring or termination or Product events driven, such as the product becoming exhausted or activated due to First Usage.

Flows

Terminology

The API adopts OAuth 2.0 with Client Credentials as its authentication mechanism, ensuring secure access to protected resources on behalf of a client application.

Although the same token can be used in multiple API calls, please be aware that these tokens have a limited duration so you need to include refresh logic in the client code, so that the token gets refreshed automatically without breaking your processing sequence.

Below is an explanation of how to obtain an access token using the Client Credentials flow, accompanied by examples.

Fetching an Access Token

1. Request an Access Token: To request an access token from the authorization server, initiate an HTTP POST request to the token endpoint. Include the following parameters:

   • grant_type: Set to "client_credentials"
   • token_url: authentication server endpoint
   • client_id: Your organization's client ID.
   • client_secret: Your organization's client secret.

2. Receive the Access Token: Upon successful authentication, you'll receive an access token

cURL Example

curl -X POST \
  https://api.1global.com/auth/realms/1global-connect/protocol/openid-connect/token \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'grant_type=client_credentials&client_id=your_client_id&client_secret=your_client_secret'

Postman Example

• Create a new request
• In the Authorization tab, set type to OAuth 2.0
• Fill in the Configure New Token form with the following values:
  • Grant Type: Client Credentials
  • Access Token URL: https://api.1global.com/auth/realms/1global-connect/protocol/openid-connect/token
  • Client ID: your_client_id
  • Client secret: your_client_secret
• Click on the Get New Access Token button, which will trigger a popup saying 'Authentication complete'.
• In the Manage Access Tokens popup, hit the Use Token
• Proceed with your request. The generated token should be valid for 5 minutes

The Activation process provides a straightforward way to provision a new eSIM from the Connect API in seconds. This flow fetches the latest available information and provisions a new eSIM in one go.

We are not recomending to use Activation flow in production.
Please consider using a combination of: Refresh Catalog and Quick Activation

Process Overview

1. The partner requests the latest product offerings from the Connect API.
2. The partner selects a product offering and initiates an activation order.
3. The API processes the order and provisions a new eSIM.
4. The partner receives the eSIM credentials.

An order can be placed for a new customer by providing the customer’s information or using the Subscriber ID.

Activation order provides an easies way to get eSIM from Connect API in seconds, please folow the API calls to get the activation code (or QR)

API Call

1. Lists all product offerings
2. Creates a new order
3. Get Order Completed Event

The Refresh Catalog process allows partners to synchronize their local product catalog with the latest offerings available from 1GLOBAL Connect. This ensures that partners always have access to the most up-to-date product information for ordering.

We recomend to Refresh Catalog once a day to have the latest offerings.

Process Overview

1. The partner initiates a request to update their local catalog.
2. The API retrieves the latest product offerings from 1GLOBAL Connect.
3. The partner's local catalog is updated with the new information.

API Call

To update the catalog, use the following API:

1. Lists all product offerings

The Quick Activation process allows partners to provision a new eSIM using pre-fetched catalog information. This method is faster and more efficient than the standard Activation flow, as it doesn't require real-time catalog updates during the activation process.

Process Overview

1. The partner uses their locally stored catalog information (previously updated via the Refresh Catalog process).
2. The partner initiates a Quick Activation request with the desired product offering.
3. The API processes the request and provisions a new eSIM.
4. The partner receives the eSIM Credentials

An order can be placed for a new customer by providing the customer’s information or using the Subscriber ID.

API Calls

To perform a Quick Activation, use the following API calls:

1. Creates a new order
2. Get Order Completed Event

By using Quick Activation, partners can significantly reduce the time required to provision new eSIMs, improving the overall user experience while maintaining up-to-date product information through regular catalog updates.

The TopUP process allows partners to add a new product to an existing customer's eSIM subscription. This feature enables customers to enhance their service without the need for a new eSIM provisioning.

Process Overview

1. The partner identifies an existing customer's subscription that requires a TopUP.
2. The partner selects an additional product from their locally stored catalog information.
3. The partner initiates a TopUP request for the existing subscription with the new product details.
4. The API processes the request and adds the new product to the customer's eSIM.
5. The partner receives confirmation of the successful TopUP.

API Calls

To perform a TopUP, use the following API calls:

1. Creates a new order (specifying the existing subscription ID and new product)
2. Get Order Completed Event

As part of the API onboarding process, we require you to provide the URL of your webhook endpoint and credentials for Basic Authentication (optional), where all events will be delivered to your environment.

Currently, webhook management, including updating endpoints, is handled manually. In the future, we plan to introduce an API that will allow you to easily manage webhook configurations.

To enhance security, we are actively working on implementing additional features alongside basic authentication, such as:

• HMAC-SHA256 signatures using a pre-shared secret key
• A robust signature verification scheme
• Webhook headers (ID, timestamp, signature)

There are several ways to install eSIM on your device.

The eSIM QR code is a crucial element for activating eSIM profiles on compatible devices. This QR code is provided in two key locations within our API:

1. Retrieve an Order: When you fetch the details of an order using the order retrieval endpoint, the response includes the QR code link for the associated eSIM.

2. Order Completed Webhook: Upon successful completion of an order, the Order Completed webhook notification also contains the QR code link.

In both cases, you can find the QR code link in the response structure under the qrcode field.

Example: In the Order Completed event the QR Code link located in: Event --> Data --> Order --> _embedded --> _links --> qrcode

Starting from iOS 17.5 an eSIM profile can be installed via link.

The link should be prepared as follows:

https://esimsetup.apple.com/esim_qrcode_provisioning?carddata=LPA:1$rsp.truphone.com$MATCHING_ID

MATCHING_ID can be obtained in Retrieve an Orde or Order Completed Webhook or from Subscription

Example of the Installation Link

Install eSIM from BetterRoaming

To enable eSIM Profile installation and APN management, please contact 1Global with information of your application: Application Hash.

Application Hash

What capabilities can be provided to an App that are linked with eSIM profile using Application Hash?

1. Install eSIM profile via Android APP
2. Manage Profiles
3. Get ICCID of the profile

This information should be delivered to 1GLOBAL during onboarding process.

Example:

Certificate: example
Application package name:    ie com.COMPANY.COMPANY
Fingerprints:
sha1 - 52:F3:08:E2:.........
sha256 - 9C:9B:E0:71:........

Useful links:

• https://developer.android.com/studio/publish/app-signing
• https://source.android.com/docs/core/connect/uicc
• https://source.android.com/docs/core/connect/esim-overview#carrier-privileges

APN configuration

On Android platform APN should be configured by the application. This allows instant access without manual actions from the user.

Documentation: https://developer.android.com/reference/android/telephony/CarrierConfigManager

Flow:

1. Get subscription list with subscription manager
2. Check that ICCID is 1Global’s
3. Verify that there is connectivity (if there is connectivity it will just update the APN, if not, it deletes and created new APN setting)
4. Run insert APN setting

To get Carrier Privileges, an eSIM must be in enabled state on the device.

Android permission manifest example:

<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.READ_PRIVILEGED_PHONE_STATE"
tools:ignore="ProtectedPermissions" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.WAKE_LOCK" />
<uses-permission android:name="android.permission.mod" />
<uses-permission
android:name="android.permission.WRITE_APN_SETTINGS"
tools:ignore="ProtectedPermissions"/>

APN settings values:

   public static ContentValues getDefaultAPN() {
        ContentValues values = new ContentValues();
        values.put(Telephony.Carriers.NAME, "1GLOBAL");
        values.put(Telephony.Carriers.APN, "truphone.com");
        values.put("user_visible", "1");
        values.put(Telephony.Carriers.MMSC, http://mmsc.truphone.com:1981/mm1);
        values.put(Telephony.Carriers.MMSPORT, "1981");
        values.put(Telephony.Carriers.NUMERIC, "20408");
        values.put(Telephony.Carriers.MCC, "204");
        values.put(Telephony.Carriers.MVNO_MATCH_DATA, "20408x");
        values.put(Telephony.Carriers.TYPE, "default,supl,dun,mms");
        values.put(Telephony.Carriers.MVNO_TYPE, "imsi");
        return values;
    }

ICCID’s from 1Global always start with:

ICCIDS = "894450,894447";

Helpful code snippets:

TelephonyManager tl = (TelephonyManager) getApplicationContext().getSystemService(Context.TELEPHONY_SERVICE);
 
        SubscriptionManager subMangager = (SubscriptionManager) getApplicationContext().getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);
 
        int subId = -1;
 
        for (SubscriptionInfo inf : subMangager.getActiveSubscriptionInfoList()) {
            if (IccidChecker.isA1GlobalIccid(inf.getIccId())) {
                subId = inf.getSubscriptionId();
                break;
            }
        }
 
        SetupApnDevice 1GlobalApnCreator = new SetupApnDevice(getApplicationContext(),subId);
 
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && subId!=-1) {
            tl=tl.createForSubscriptionId(subId);
        }
 
try {
 
            ConnectivityManager cm =
                    (ConnectivityManager)getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
 
            NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
            boolean isConnected = activeNetwork != null &&
                    activeNetwork.isConnected();
 
                1GlobalApnCreator.execute(tl.getSubscriberId().substring(0, 5),String.valueOf(isConnected));
 
        }catch (Exception e){
            ApnException.response();
        }

SetupApnDevice class:

protected String doInBackground(String... params) {
        String response;
 

        this.numeric=params[0];
        boolean isConnected= Boolean.parseBoolean(params[1]);
 

        try {
 
            1GlobalApnDevice 1GlobalApnDevice = new 1GlobalApnDevice(context);
 
            1GlobalApnDevice.setNumeric(this.numeric);
            1GlobalApnDevice.setSubId(this.subId);
 
            if(isConnected) {
                1GlobalApnDevice.execute();
            }else{
                1GlobalApnDevice.executeForce();
            }
 

            PreferredApnDevice preferredApnDevice = new PreferredApnDevice(context, 1GlobalApnDevice.getId());
            preferredApnDevice.setNumeric(this.numeric);
            preferredApnDevice.execute();
 

            response = MessageDisplay.OK.toString();
 
        }catch(Exception ex){
            DeviceContent.getContent().setMessage(MessageDescription.CARRIER_PRIVILEGES.getKey());
 
            response = MessageDisplay.NOK.toString();
        }
 
        return response;
    }

PreferredApnDevice class

public class PreferredApnDevice implements Apn {
 
    private Uri PREFERRED_APN_URI = Uri.parse("content://telephony/carriers/preferapn");
 
    private ProviderAccess currentApnDevice;
    private int id;
    private String numeric;
 
    public PreferredApnDevice(Context context, int id, int subId) {
 
        this.id = id;
 
        currentApnDevice = new CurrentApnDevice(Uri.withAppendedPath(PREFERRED_APN_URI, "subId/" + String.valueOf(subId)), context);
    }
 
    public PreferredApnDevice(Context context, int id) {
 
        this.id = id;
 
        currentApnDevice = new CurrentApnDevice(PREFERRED_APN_URI, context);
    }
 
    @Override
    public void execute() {
 
        currentApnDevice.update(getContentValues(),null,null);
    }
 
    @Override
    public ContentValues getContentValues() {
        ContentValues contentValues = new ContentValues();
 
        contentValues.put(ApnUtils.APN_ID.getName(),String.valueOf(id));
        return contentValues;
    }
 
    public void setNumeric(String numeric) {
        this.numeric=numeric;
    }
 
}

1GlobalApnDevice:

public class 1GlobalApnDevice implements Apn {
 
    private CurrentApnDevice currentApnDevice;
 
    private String numeric;
    private int subId;
 
    public 1GlobalApnDevice(Context context){
 
        currentApnDevice = new CurrentApnDevice(Telephony.Carriers.CONTENT_URI, context);
    }
 
    public int getId() {
 
        return currentApnDevice.getId();
    }
 
    public String getNumeric() {
 
        return numeric;
    }
 
    public void setNumeric(String numeric) {
 
        this.numeric = numeric;
    }
 

    @Override
    public void execute() {
 

        if(getId() == 0){
            currentApnDevice.insert(getContentValues());
        }else{
            currentApnDevice.update(getContentValues(), currentApnDevice.getQuery(), currentApnDevice.getSelectionArgs());
        }
    }
 
   @Override
    public ContentValues getContentValues() {
        ContentValues contentValues = new ContentValues();
 
        contentValues.put(ApnUtils.APN_NAME.getName(), ApnUtils.APN_NAME.getValue());
        contentValues.put(ApnUtils.APN.getName(), ApnUtils.APN.getValue());
        contentValues.put(ApnUtils.APN_NUMERIC.getName(), numeric);
        contentValues.put(ApnUtils.APN_MCC.getName(), numeric.substring(0,3));
        contentValues.put(ApnUtils.APN_MNC.getName(), numeric.substring(3));
        contentValues.put(ApnUtils.APN_MVNO_TYPE.getName(), ApnUtils.APN_MVNO_TYPE.getValue());
        contentValues.put(ApnUtils.APN_CURRENT.getName(), ApnUtils.APN_CURRENT.getValue());
        contentValues.put(ApnUtils.APN_MVNO_DATA.getName(), numeric + ApnUtils.APN_MVNO_DATA.getValue());
        contentValues.put(ApnUtils.APN_TYPE.getName(), ApnUtils.APN_TYPE.getValue());
        contentValues.put(ApnUtils.APN_MMSC.getName(), ApnUtils.APN_MMSC.getValue());
        contentValues.put(ApnUtils.APN_MMSC_PORT.getName(), ApnUtils.APN_MMSC_PORT.getValue());
        contentValues.put(ApnUtils.APN_SUBID.getName(),subId);
 
        return contentValues;
    }
 
    public void setSubId(int subId) {
        this.subId = subId;
    }
 
    public int getSubId() {
        return subId;
    }
 
    public void executeForce() {
        if(getId() == 0){
            currentApnDevice.insert(getContentValues());
        }else{
            currentApnDevice.delete(currentApnDevice.getQuery(), currentApnDevice.getSelectionArgs());
            currentApnDevice.insert(getContentValues());
        }
 
    }
}

CurretnApnDevice:

public class CurrentApnDevice extends ProviderAccess {
    private ApnAttributes apnCreateClause;
    private String[] selectionArgs;
    private String query;
 
    public CurrentApnDevice(Uri uri, Context context) {
        super(uri, context.getContentResolver());
 
        apnCreateClause = new ApnAttributes(ApnUtils.APN.getValue(), ApnUtils.APN_NAME.getValue());
        selectionArgs = apnCreateClause.getSelectionArgs();
        query = apnCreateClause.toString();
    }
 
    public void log(){
        logAPN(query,selectionArgs);
    }
 
    public int getId() {
 
        return select(query, selectionArgs);
    }
 
    public String[] getSelectionArgs() {
 
        return selectionArgs;
    }
 
    public void setSelectionArgs(String[] selectionArgs) {
 
        this.selectionArgs = selectionArgs;
    }
 
    public String getQuery() {
 
        return query;
    }
 
    public void setQuery(String query) {
 
        this.query = query;
 
    }
}

providerAccess class

package com.1Global.1GlobalApp.contentresolver;

import android.content.ContentResolver;
import android.content.ContentValues;
import android.database.Cursor;
import android.net.Uri;
import android.util.Log;

public abstract class ProviderAccess {

    protected Uri uri;
    protected ContentResolver contentResolver;

    public ProviderAccess(Uri uri, ContentResolver contentResolver){
        this.uri = uri;
        this.contentResolver = contentResolver;
    }

    public int select(String query, String[] arguments) {
        Cursor c = contentResolver.query(uri, null, query, arguments, null);
        int value = 0;

        if(c.moveToFirst()){

            value = c.getShort(0);
        }
        c.close();

        return value;
    }

    public void insert(ContentValues contentValues){

        try{
            contentResolver.insert(uri,contentValues);

        }catch(Exception ex){

            Log.d(ProviderAccess.class.getName(), "insert APN: " + ex.getMessage());
        }
    }

    public int update(ContentValues contentValues, String query, String[] arguments){

        try {

            int apnid= contentResolver.update(uri, contentValues, query, arguments);

            return apnid;
        }catch(Exception ex){

            Log.d(ProviderAccess.class.getName(), "update APN: " + ex.getMessage());
            return -1;
        }
    }

    public void delete(String query, String[] arguments){

        contentResolver.delete(uri, query, arguments);
    }
}