apn相关

		//apn相关参数变量
		private String name;

    private String apn;

    private String proxy;

    private String port;

    private String user;

    private String server;

    private String password;

    private String mmsc;

    private String mmsproxy;

    private String mmsport;

    private String mcc;

    private String mnc;

    private String numeric;

    private String type;
    
    private static final Uri APN_TABLE_URI = Uri.parse("content://telephony/carriers");

    private static final Uri PREFERRED_APN_URI = Uri.parse("content://telephony/carriers/preferapn");
    
    //相关方法
    public String getMcc()
    {
        TelephonyManager tm =
            (TelephonyManager)parentContext.getSystemService(Context.TELEPHONY_SERVICE);
        String numeric = tm.getSimOperator();
        String mcc = numeric.substring(0, 3);
        return mcc;
    }
    
    public String getSimOperator()
    {
        TelephonyManager tm = (TelephonyManager) parentContext.getSystemService(Context.TELEPHONY_SERVICE);
        String simOperator = tm.getSimOperator();
        return simOperator;
    }
    
    public String getSimOperator()
    {
        TelephonyManager tm = (TelephonyManager) parentContext.getSystemService(Context.TELEPHONY_SERVICE);
        String simOperator = tm.getSimOperator();
        return simOperator;
    }
    
    public ApnNode getDefaultAPN()
    {
        String apn = "";
        String proxy = "";
        String name = "";
        String port = "";
        String mnc = "";
        String mcc = "";
        String id = "";
        ApnNode apnNode = new ApnNode();
        Cursor cursor = null;

        cursor = parentContext.getContentResolver().query(PREFERRED_APN_URI,
                null,
                null,
                null,
                null);
        if (cursor == null)
        {
            return null;

        }
        try
        {
            if (cursor.moveToFirst())
            {
                id = cursor.getString(cursor.getColumnIndex("_id"));
                name = cursor.getString(cursor.getColumnIndex("name"));
                apn = cursor.getString(cursor.getColumnIndex("apn"))
                        .toLowerCase();
                proxy = cursor.getString(cursor.getColumnIndex("proxy"));
                port = cursor.getString(cursor.getColumnIndex("port"));
                mnc = cursor.getString(cursor.getColumnIndex("mnc"));
                mcc = cursor.getString(cursor.getColumnIndex("mcc"));
            }

            //Get system default APN ID, NOTE, if phone doese not have any APN, its id is "" string.
            if (id != null && !id.equals(""))
            {
                if (iSystemUsedApnID == -1)
                {
                    iSystemUsedApnID = Integer.parseInt(id);
                }
                iCurrentUsedApnID = iAppUsedApnID = Integer.parseInt(id);//if it is app want, then it also assign this value to appUsedID;
                isNoneAPN = false;
            }
            else
            {
                isNoneAPN = true;//this setting will ensure iSystemApnID will be init properly.
            }
            apnNode.setName(name);
            apnNode.setApn(apn);
            apnNode.setProxy(proxy);
            apnNode.setPort(port);
            apnNode.setMnc(mnc);
            apnNode.setMcc(mcc);
        }
        catch (Exception e)
        {
            Log.e(TAG, e.toString());
        }
        finally
        {
            cursor.close();
        }
        return apnNode;
    }
    
    public int addNewApn(ApnNode apnNode)
    {
        int apnId = -1;
        ContentResolver resolver = parentContext.getContentResolver();
        ContentValues values = new ContentValues();
        values.put("name", apnNode.getName());
        values.put("apn", apnNode.getApn());
        values.put("proxy", apnNode.getProxy());
        values.put("port", apnNode.getPort());
        values.put("user", apnNode.getUser());
        values.put("password", apnNode.getPassword());
        values.put("mcc", apnNode.getMcc());
        values.put("mnc", apnNode.getMnc());
        values.put("numeric", apnNode.getNumeric());
        // Note: this values need to be update, and for now, it only for XT800.

        Cursor cursor = null;
        try
        {
            Uri newRow = resolver.insert(APN_TABLE_URI, values);
            if (newRow != null)
            {
                cursor = resolver.query(newRow, null, null, null, null);

                int idindex = cursor.getColumnIndex("_id");
                int apn = cursor.getColumnIndex("apn");
                cursor.moveToFirst();
                apnId = cursor.getShort(idindex);
                String apnString;
                apnString = cursor.getString(apn);
                Log.d("Robert", "New ID: " + apnId
                        + ": Inserting new APN succeeded!" + apnString);
            }
        }
        catch (SQLException e)
        {
            Log.e(TAG, e.toString());
        }
        finally
        {
            if (cursor != null)
            {
                cursor.close();
            }
        }
        //if addNew, that means this apn will be ussed as iAppUsedApnID
        iAppUsedApnID = apnId;
        if (isNoneAPN && iSystemUsedApnID == -1) //if none of any APN exists, we should init iSystemUsedApnID
        {
            iSystemUsedApnID = apnId;
        }
        return apnId;
    }
    
    public int isApnExisted(ApnNode apnNode)
    {

        int apnId = -1;
        Cursor cursor = parentContext.getContentResolver()
                .query(APN_TABLE_URI,
                        null,
                        "apn=? and proxy=? and port=? and mcc=? and mnc=?",
                        new String[]
                        {
                                apnNode.getApn(), apnNode.getProxy(),
                                apnNode.getPort(), apnNode.getMcc(),
                                apnNode.getMnc()
                         },
                        null);
        if (cursor != null && cursor.moveToFirst())
        {
            apnId = cursor.getInt(cursor.getColumnIndex("_id"));
        }
        if (cursor != null)
        {
            cursor.close();
        }
        return apnId;
    }
    
    public int setApn(ApnNode apnNode)
    {
        int apnId = isApnExisted(apnNode);
        ApnNode defaultApn = getDefaultAPN();
        if (apnId == -1)
        {
            int addNum = addNewApn(apnNode);
            if (addNum == -1)
            {
                return addNum;
            }
            else
            {
                setBroadCast(apnNode.getApn());
                return setAPNDefault(addNum);
            }
        }
        else
        {
            if (defaultApn.getApn().equals(apnNode.getApn())
                && defaultApn.getMcc().equals(apnNode.getMcc())
                && defaultApn.getMnc().equals(apnNode.getMnc())
                && defaultApn.getPort().equals(apnNode.getPort())
                && defaultApn.getProxy().equals(apnNode.getProxy()))
            {
                return 0;
            }
            else
            {
                setBroadCast(apnNode.getApn());
                return setAPNDefault(apnId);
            }
        }
    }
    
    public void setBroadCast(String defaultApn){
        IntentFilter upIntentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION); 
        NetworkChangeReceiver mNChangeReceiver  =NetworkChangeReceiver.getInstance(defaultApn);
        context.registerReceiver(mNChangeReceiver, upIntentFilter); 
    }
    
    //receive  ConnectivityManager.CONNECTIVITY_ACTION
    public void onReceive(Context context, Intent intent)
    {
        if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction()))
        {

            ConnectivityManager conManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo info = conManager
                .getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
            String apn = info.getExtraInfo();
            Log.d(TAG, "apn:" + apn + " info.isConnected():"
                + info.isConnected());
            if (defaultApn.equals(apn) && info.isConnected())
            {
                if (mNetworkChangeReceiver != null)
                {
                    context.sendBroadcast(new Intent(NETWORK_IS_OK));
                    context.unregisterReceiver(mNetworkChangeReceiver);
                    mNetworkChangeReceiver = null;
                }
            }
        }
    }