如何在Android應用程序中使用3G連接而不是Wi-Fi？

Question

如何在Android應用程序中使用3G連接而不是Wi-Fi？

我想連接3G連接，是否有任何示例代碼連接到3G而不是Wi-fi？

Answer 1

T-Mobile的「我的帳戶」應用程序會這樣做，如果您連接到WiFi連接，它會告訴您他們的程序無法通過WiFi工作，然後詢問用戶是否要關閉WiFi連接。如果你選擇「否」，那麼應用程序退出，如果你選擇「是」，那麼應用程序關閉你的WiFi連接，然後繼續啓動。

我認爲這是一個很好的模型，它會確保您的應用程序不會在WiFi上運行，並允許用戶決定是否要關閉WiFi。對此模型的改進是在用戶從您的應用程序導航離開時將WiFi重新開啓。沒有測試過d下面的代碼，但它看起來像它應該工作（從here修改）

使用下面的權限，您的清單

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"></uses-permission> 
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE"></uses-permission> 

，這裏是一些實際的代碼來打開WiFi /關閉

private WifiManager wifiManager; 

@Override 
public void onCreate(Bundle icicle) 
{ 
    .................... 

    wifiManager = (WifiManager) this.getSystemService(Context.WIFI_SERVICE); 

    if(wifiManager.isWifiEnabled()) 
    { 
     wifiManager.setWifiEnabled(false); 
    } 
    else 
    { 
     wifiManager.setWifiEnabled(true); 
    } 
} 

如果你不想沿着這條路線走，看起來你可能會告訴手機你更喜歡使用移動數據網絡而不是WiFi網絡。

Android ConnectivityManager提供功能setNetworkPreference。這個功能沒有真正的記錄，因爲你可以告訴你是否點擊鏈接。我會仔細研究它，因爲定義的常量似乎暗示您可以將其設置爲TYPE_MOBILE或TYPE_WIFI，並且還有一個DEFAULT_NETWORK_PREFERENCE常量，它被定義爲0x00000001，它與TYPE_WIFI相同。因此，請嘗試通過調用

Context.getSystemService(Context.CONNECTIVITY_SERVICE); 

訪問ConnectivityManager，然後嘗試使用setNetworkPreference（）函數。

它似乎不需要清單中的任何權限，但它可能需要CHANGE_NETWORK_STATE權限或沿着這些行的東西。

如果你起訴setNetworkPreference功能它很可能是最好也設置網絡偏好回原來的值（從getNetworkPreference收到）

我希望這有助於。

Answer 2

我認爲這是不可能從Java。如果連接到無線網絡，系統將關閉所有基於移動網絡的通信。我認爲你不能從你的程序開始3G連接。

Answer 3

/** 
* Enable mobile connection for a specific address 
* @param context a Context (application or activity) 
* @param address the address to enable 
* @return true for success, else false 
*/ 
private boolean forceMobileConnectionForAddress(Context context, String address) { 
    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); 
    if (null == connectivityManager) { 
     Log.debug(TAG_LOG, "ConnectivityManager is null, cannot try to force a mobile connection"); 
     return false; 
    } 

    //check if mobile connection is available and connected 
    State state = connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE_HIPRI).getState(); 
    Log.debug(TAG_LOG, "TYPE_MOBILE_HIPRI network state: " + state); 
    if (0 == state.compareTo(State.CONNECTED) || 0 == state.compareTo(State.CONNECTING)) { 
     return true; 
    } 

    //activate mobile connection in addition to other connection already activated 
    int resultInt = connectivityManager.startUsingNetworkFeature(ConnectivityManager.TYPE_MOBILE, "enableHIPRI"); 
    Log.debug(TAG_LOG, "startUsingNetworkFeature for enableHIPRI result: " + resultInt); 

    //-1 means errors 
    // 0 means already enabled 
    // 1 means enabled 
    // other values can be returned, because this method is vendor specific 
    if (-1 == resultInt) { 
     Log.error(TAG_LOG, "Wrong result of startUsingNetworkFeature, maybe problems"); 
     return false; 
    } 
    if (0 == resultInt) { 
     Log.debug(TAG_LOG, "No need to perform additional network settings"); 
     return true; 
    } 

    //find the host name to route 
    String hostName = StringUtil.extractAddressFromUrl(address); 
    Log.debug(TAG_LOG, "Source address: " + address); 
    Log.debug(TAG_LOG, "Destination host address to route: " + hostName); 
    if (TextUtils.isEmpty(hostName)) hostName = address; 

    //create a route for the specified address 
    int hostAddress = lookupHost(hostName); 
    if (-1 == hostAddress) { 
     Log.error(TAG_LOG, "Wrong host address transformation, result was -1"); 
     return false; 
    } 
    //wait some time needed to connection manager for waking up 
    try { 
     for (int counter=0; counter<30; counter++) { 
      State checkState = connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE_HIPRI).getState(); 
      if (0 == checkState.compareTo(State.CONNECTED)) 
       break; 
      Thread.sleep(1000); 
     } 
    } catch (InterruptedException e) { 
     //nothing to do 
    } 
    boolean resultBool = connectivityManager.requestRouteToHost(ConnectivityManager.TYPE_MOBILE_HIPRI, hostAddress); 
    Log.debug(TAG_LOG, "requestRouteToHost result: " + resultBool); 
    if (!resultBool) 
     Log.error(TAG_LOG, "Wrong requestRouteToHost result: expected true, but was false"); 

    return resultBool; 
} 

這對於計算主機地址：

/** 
* This method extracts from address the hostname 
* @param url eg. http://some.where.com:8080/sync 
* @return some.where.com 
*/ 
public static String extractAddressFromUrl(String url) { 
    String urlToProcess = null; 

    //find protocol 
    int protocolEndIndex = url.indexOf("://"); 
    if(protocolEndIndex>0) { 
     urlToProcess = url.substring(protocolEndIndex + 3); 
    } else { 
     urlToProcess = url; 
    } 

    // If we have port number in the address we strip everything 
    // after the port number 
    int pos = urlToProcess.indexOf(':'); 
    if (pos >= 0) { 
     urlToProcess = urlToProcess.substring(0, pos); 
    } 

    // If we have resource location in the address then we strip 
    // everything after the '/' 
    pos = urlToProcess.indexOf('/'); 
    if (pos >= 0) { 
     urlToProcess = urlToProcess.substring(0, pos); 
    } 

    // If we have ? in the address then we strip 
    // everything after the '?' 
    pos = urlToProcess.indexOf('?'); 
    if (pos >= 0) { 
     urlToProcess = urlToProcess.substring(0, pos); 
    } 
    return urlToProcess; 
} 

/** 
* Transform host name in int value used by {@link ConnectivityManager.requestRouteToHost} 
* method 
* 
* @param hostname 
* @return -1 if the host doesn't exists, elsewhere its translation 
* to an integer 
*/ 
private static int lookupHost(String hostname) { 
    InetAddress inetAddress; 
    try { 
     inetAddress = InetAddress.getByName(hostname); 
    } catch (UnknownHostException e) { 
     return -1; 
    } 
    byte[] addrBytes; 
    int addr; 
    addrBytes = inetAddress.getAddress(); 
    addr = ((addrBytes[3] & 0xff) << 24) 
      | ((addrBytes[2] & 0xff) << 16) 
      | ((addrBytes[1] & 0xff) << 8) 
      | (addrBytes[0] & 0xff); 
    return addr; 
} 

而且下列權限必須添加到AndroidManifest。XML

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/> 
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" /> 

它僅適用於Android 2.2以上版本，兩個歌Nexus One和LG擎天柱測試，其他手機我不知道，因爲ConnectivityMananger的一些方法是供應商特定的。 閒置15-20秒後，移動網絡會自動斷開連接。

Answer 4

此應用程序激活3G和Wifi連接，優先選擇3G！ 非常有用http://www.redrails.com.br/2012/02/wireless-analyzer-for-android/

Answer 5

使用連接管理器並根據需要設置網絡首選項。 好luk

例如： dataManager =（ConnectivityManager）getSystemService（CONNECTIVITY_SERVICE）; dataManager.setNetworkPreference（ConnectivityManager.TYPE_MOBILE）; dataManager.setNetworkPreference（ConnectivityManager.TYPE_MOBILE）;

Answer 6

受此門票中的代碼的啓發，並使用它的一些部分，這裏是建立hipri移動並使其保持運行的服務。

import java.net.InetAddress; 
import java.net.UnknownHostException; 
import java.util.concurrent.atomic.AtomicBoolean; 

import android.app.Service; 
import android.content.Context; 
import android.content.Intent; 
import android.net.ConnectivityManager; 
import android.net.NetworkInfo.State; 
import android.os.IBinder; 
import android.util.Log; 

public class HipriService extends Service { 
    private AtomicBoolean enabledMobile = new AtomicBoolean(false); 

    public boolean enableMobileConnection() { 
     ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); 
     if (null == cm) { 
      Log.d(TAG, "ConnectivityManager is null, cannot try to force a mobile connection"); 
      return false; 
     } 

     /* 
     * Don't do anything if we are connecting. On the other hands re-new 
     * connection if we are connected. 
     */ 
     State state = cm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE_HIPRI).getState(); 
     Log.d(TAG, "TYPE_MOBILE_HIPRI network state: " + state); 
     if (0 == state.compareTo(State.CONNECTING)) 
      return true; 

     /* 
     * Re-activate mobile connection in addition to other connection already 
     * activated 
     */ 
     int resultInt = cm.startUsingNetworkFeature(ConnectivityManager.TYPE_MOBILE, "enableHIPRI"); 
     //Log.d(TAG, "startUsingNetworkFeature for enableHIPRI result: " + resultInt); 

     //-1 means errors 
     // 0 means already enabled 
     // 1 means enabled 
     // other values can be returned, because this method is vendor specific 
     if (-1 == resultInt) { 
      Log.e(TAG, "Wrong result of startUsingNetworkFeature, maybe problems"); 
      return false; 
     } 
     if (0 == resultInt) { 
      Log.d(TAG, "No need to perform additional network settings"); 
      return true; 
     } 

     return requestRouteToHost(this, Uploader.ServerAddress); 
    } 

    private Thread pingerThread = null; 

    private void startMobileConnection() { 
     enabledMobile.set(true); 
     pingerThread = new Thread(new Runnable() { 
      @Override 
      public void run() { 
       while (enabledMobile.get()) { 
        /* 
        * Renew mobile connection. No routing setup is needed. This 
        * should be moved to 3g monitoring service one day. 
        */ 
        enableMobileConnection(); 
        try { 
         Thread.sleep(1000); 
        } catch (InterruptedException e) { 
         // do nothing 
        } 
       } 
      } 
     }); 
     pingerThread.start(); 
    } 

    private void stopMobileConnection() { 
     enabledMobile.set(false); 
     disableMobileConnection(); 
     pingerThread.interrupt(); 
     pingerThread = null; 
    } 

    public void disableMobileConnection() { 
     ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); 
     cm.stopUsingNetworkFeature(ConnectivityManager.TYPE_MOBILE, "enableHIPRI"); 
    } 

    public final static int inetAddressToInt(InetAddress inetAddress) { 
     byte[] addrBytes; 
     int addr; 
     addrBytes = inetAddress.getAddress(); 
     addr = ((addrBytes[3] & 0xff) << 24) | ((addrBytes[2] & 0xff) << 16) | ((addrBytes[1] & 0xff) << 8) 
       | (addrBytes[0] & 0xff); 
     return addr; 
    } 

    public final static InetAddress lookupHost(String hostname) { 
     try { 
      return InetAddress.getByName(hostname); 
     } catch (UnknownHostException e) { 
      return null; 
     } 
    } 

    private boolean requestRouteToHost(Context context, String hostname) { 
     ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); 
     if (null == cm) { 
      Log.d(TAG, "ConnectivityManager is null, cannot try to force a mobile connection"); 
      return false; 
     } 

     /* Wait some time needed to connection manager for waking up */ 
     try { 
      for (int counter = 0; enabledMobile.get() && counter < 30; counter++) { 
       State checkState = cm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE_HIPRI).getState(); 
       Log.i(TAG, "Waiting for mobile data on. State " + checkState); 
       if (0 == checkState.compareTo(State.CONNECTED)) 
        break; 
       Thread.sleep(1000); 
      } 
     } catch (InterruptedException e) { 
      //nothing to do 
     } 

     if (!enabledMobile.get()) { 
      Log.d(TAG, "Mobile data is turned off while waiting for routing."); 
      return false; 
     } 

     State checkState = cm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE_HIPRI).getState(); 
     if (0 != checkState.compareTo(State.CONNECTED)) { 
      Log.e(TAG, "Mobile data is still turned off after 30 sec of waiting."); 
      return false; 
     } 
     Log.i(TAG, "Adding routing for " + hostname); 

     InetAddress inetAddress = lookupHost(hostname); 
     if (inetAddress == null) { 
      Log.e(TAG, "Failed to resolve " + hostname); 
      return false; 
     } 
     int hostAddress = inetAddressToInt(inetAddress); 

     boolean resultBool = cm.requestRouteToHost(ConnectivityManager.TYPE_MOBILE_HIPRI, hostAddress); 
     Log.d(TAG, "requestRouteToHost result: " + resultBool); 
     if (!resultBool) 
      Log.e(TAG, "Wrong requestRouteToHost result: expected true, but was false"); 

     return resultBool; 
    } 

    @Override 
    public void onCreate() { 
     super.onCreate(); 
     startMobileConnection(); 
    } 

    @Override 
    public void onDestroy() { 
     stopMobileConnection(); 
     super.onDestroy(); 
    } 

    @Override 
    public IBinder onBind(Intent intent) { 
     return null; 
    } 

} 

這是我如何在需要時啓動/停止它。請注意，它也會鎖定cpu和wifi，以便在手機睡眠時運行（僅限屏幕）。 Wifi是需要的，因爲我的應用程序是WiFi和移動連接之間的橋樑。你可能不需要它。

public void startMobileData() { 
    if (!enabledMobile.get()) { 
     enabledMobile.set(true); 
     WifiManager wm = (WifiManager) getSystemService(Context.WIFI_SERVICE); 
     wifiLock = wm.createWifiLock(WifiManager.WIFI_MODE_FULL, "Wifi Wakelock"); 
     wifiLock.acquire(); 

     PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); 
     partialLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "3G Wakelock"); 
     partialLock.acquire(); 

     startService(new Intent(this, HipriService.class)); 
    } 
} 

public void stopMobileData() { 
    if (enabledMobile.get()) { 
     enabledMobile.set(false); 
     Log.i(TAG, "Disabled mobile data"); 
     stopService(new Intent(this, HipriService.class)); 

     if (partialLock != null) { 
      partialLock.release(); 
      partialLock = null; 
     } 

     if (wifiLock != null) { 
      wifiLock.release(); 
      wifiLock = null; 
     } 
    } 
} 

不要忘記爲您的清單文件添加服務。

Answer 7

@umka

• 我認爲，應用只能達到通過HIPRI它已經請求的那些宿主，可以是用於其他主機（其路由請求）使用默認網絡（MOBILE或WIFI ）。
• 打電話stopUsingNetworkFeature（），它會檢查 - 是否有任何其他應用程序正在使用此網絡，如果是，那麼它將忽略您的請求關閉此網絡功能。
• HIPRI網絡的主要目的之一就是 - 如果wifi在運行並且一個應用想要使用移動網絡（3G）到達特定的主機，它可以通過HIPRI網絡到達。

Answer 8

以下是適用於API 21+（棒棒糖，棉花糖..）的代碼。 我更喜歡使用OkHttp與Network.getSocketFactory（），但Network.openURLConnection（）也正常工作。

private void doTest() 
{ 
    display("Requesting CELLULAR network connectivity..."); 
    ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE); 

    NetworkRequest request = new NetworkRequest.Builder() 
      .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR) 
      .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build(); 

    connectivityManager.requestNetwork(request, new ConnectivityManager.NetworkCallback() 
    { 
     /** 
     * Called when the framework connects and has declared a new network ready for use. 
     * This callback may be called more than once if the {@link Network} that is 
     * satisfying the request changes. 
     * 
     * This method will be called on non-UI thread, so beware not to use any UI updates directly. 
     * 
     * @param network The {@link Network} of the satisfying network. 
     */ 
     @Override 
     public void onAvailable(final Network network) 
     { 
      display("Got available network: " + network.toString()); 

      try 
      { 
       final InetAddress address = network.getByName("navalclash.com"); 
       display("Resolved host2ip: " + address.getHostName() + " -> " + address.getHostAddress()); 
      } 
      catch (UnknownHostException e) 
      { 
       e.printStackTrace(); 
      } 

      display("Do request test page from remote http server..."); 

      if(okHttpClient == null) 
      { 
       okHttpClient = new OkHttpClient.Builder().socketFactory(network.getSocketFactory()).build(); 
      } 

      Request request = new Request.Builder() 
        .url("http://navalclash.com") 
        .build(); 
      try (Response response = okHttpClient.newCall(request).execute()) 
      { 
       display("RESULT:\n" + response.body().string()); 
      } 
      catch (Exception ex) 
      { 
       ex.printStackTrace(); 
      } 
     } 
    }); 
}