Android之指南針（電子羅盤）學習

時間  2020-09-14
標籤 android 指南針 電子 羅盤 學習 欄目 Android 简体版
原文   原文鏈接

點我下載源碼html

5月12日更新到V5版：http://download.csdn.net/detail/weidi1989/5364243java

 

今天，在小米的開源項目中下載了一個指南針源碼學習了一下，感受不只界面作得很漂亮，代碼也是很精緻，因此我在研究了以後，加了比較多的註釋，果斷跟你們分享一下，很精簡的幾段代碼，仔細品味能夠學到不少東西，我稍微總結一下：android

①.handler的靈活運用，每20秒後執行一次本身，用來檢測方向變化值，更新指南針旋轉。git

②.傳感器和谷歌位置服務的使用。canvas

③.自定義View，這裏面是自定義一個ImageView，本身增長一個旋轉圖片的方法。網絡

④.Android動畫Interpolator插入器：AccelerateInterpolator加速插入器的運用。順便說一下另外幾個插入器：app

                                     ——AccelerateInterpolator：動畫從開始到結束，變化率是一個加速的過程。ide

                                     ——DecelerateInterpolator：動畫從開始到結束，變化率是一個減速的過程。佈局

                                     ——CycleInterpolator：動畫從開始到結束，變化率是循環給定次數的正弦曲線。post

                                    ——AccelerateDecelerateInterpolator：動畫從開始到結束，變化率是先加速後減速的過程。

                                     ——LinearInterpolator：動畫從開始到結束，變化率是線性變化。
                                    AccelerateInterpolator有一個方法:getInterpolation(float input);

⑤.巧妙的數字替換成對應的數字圖片和根據本地語言使用對應的圖片資源(圖片資源國際化，哈哈)。還有一些其餘的小知識，朋友們，本身下載去研究吧！

 

下面看一下效果圖(個人是模擬器，木有傳感器也木有定位的)：

 

下面咱們來看一下這個界面的佈局文件(main.xml)：

[html] view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:layout_width="fill_parent"  
  4.     android:layout_height="fill_parent" >  
  5.   
  6.     <FrameLayout  
  7.         android:layout_width="fill_parent"  
  8.         android:layout_height="fill_parent"  
  9.         android:background="@drawable/background" >  
  10.   
  11.         <LinearLayout  
  12.             android:id="@+id/view_compass"  
  13.             android:layout_width="fill_parent"  
  14.             android:layout_height="fill_parent"  
  15.             android:background="@drawable/background_light"  
  16.             android:orientation="vertical" >  
  17.   
  18.             <LinearLayout  
  19.                 android:layout_width="fill_parent"  
  20.                 android:layout_height="0dip"  
  21.                 android:layout_weight="1"  
  22.                 android:orientation="vertical" >  
  23.   
  24.                 <FrameLayout  
  25.                     android:layout_width="fill_parent"  
  26.                     android:layout_height="wrap_content"  
  27.                     android:background="@drawable/prompt" >  
  28.   
  29.                     <LinearLayout  
  30.                         android:layout_width="fill_parent"  
  31.                         android:layout_height="wrap_content"  
  32.                         android:layout_gravity="center_horizontal"  
  33.                         android:layout_marginTop="70dip"  
  34.                         android:orientation="horizontal" >  
  35.   
  36.                         <LinearLayout  
  37.                             android:id="@+id/layout_direction"  
  38.                             android:layout_width="0dip"  
  39.                             android:layout_height="wrap_content"  
  40.                             android:layout_weight="1"  
  41.                             android:gravity="right"  
  42.                             android:orientation="horizontal" >  
  43.                         </LinearLayout>  
  44.   
  45.                         <ImageView  
  46.                             android:layout_width="20dip"  
  47.                             android:layout_height="fill_parent" >  
  48.                         </ImageView>  
  49.   
  50.                         <LinearLayout  
  51.                             android:id="@+id/layout_angle"  
  52.                             android:layout_width="0dip"  
  53.                             android:layout_height="wrap_content"  
  54.                             android:layout_weight="1"  
  55.                             android:gravity="left"  
  56.                             android:orientation="horizontal" >  
  57.                         </LinearLayout>  
  58.                     </LinearLayout>  
  59.                 </FrameLayout>  
  60.   
  61.                 <LinearLayout  
  62.                     android:layout_width="fill_parent"  
  63.                     android:layout_height="0dip"  
  64.                     android:layout_weight="1"  
  65.                     android:orientation="vertical" >  
  66.   
  67.                     <FrameLayout  
  68.                         android:layout_width="fill_parent"  
  69.                         android:layout_height="wrap_content"  
  70.                         android:layout_gravity="center" >  
  71.   
  72.                         <ImageView  
  73.                             android:layout_width="wrap_content"  
  74.                             android:layout_height="wrap_content"  
  75.                             android:layout_gravity="center"  
  76.                             android:src="@drawable/background_compass" />  
  77.   
  78.                         <net.micode.compass.CompassView  
  79.                             android:id="@+id/compass_pointer"  
  80.                             android:layout_width="wrap_content"  
  81.                             android:layout_height="wrap_content"  
  82.                             android:layout_gravity="center"  
  83.                             android:src="@drawable/compass" />  
  84.   
  85.                         <ImageView  
  86.                             android:layout_width="wrap_content"  
  87.                             android:layout_height="wrap_content"  
  88.                             android:layout_gravity="center"  
  89.                             android:src="@drawable/miui_cover" />  
  90.                     </FrameLayout>  
  91.                 </LinearLayout>  
  92.             </LinearLayout>  
  93.   
  94.             <FrameLayout  
  95.                 android:id="@+id/location_layout"  
  96.                 android:layout_width="fill_parent"  
  97.                 android:layout_height="wrap_content" >  
  98.   
  99.                 <LinearLayout  
  100.                     android:layout_width="fill_parent"  
  101.                     android:layout_height="wrap_content"  
  102.                     android:background="@drawable/background_bottom"  
  103.                     android:orientation="vertical" >  
  104.                 </LinearLayout>  
  105.   
  106.                 <TextView  
  107.                     android:id="@+id/textview_location"  
  108.                     android:layout_width="wrap_content"  
  109.                     android:layout_height="wrap_content"  
  110.                     android:layout_gravity="center"  
  111.                     android:text="@string/getting_location"  
  112.                     android:textAppearance="?android:attr/textAppearanceMedium"  
  113.                     android:textColor="#7FFFFFFF" />  
  114.             </FrameLayout>  
  115.         </LinearLayout>  
  116.     </FrameLayout>  
  117.   
  118. </FrameLayout>  


這其中用到了一個自定義view，其實就是中間那個能夠旋轉的指南針，咱們也來看看它的代碼(CompassView.java)：

[java] view plain copy
  1. /** 
  2.  * 自定義一個View繼承ImageView，增長一個通用的旋轉圖片資源的方法 
  3.  *  
  4.  * @author way 
  5.  *  
  6.  */  
  7. public class CompassView extends ImageView {  
  8.     private float mDirection;// 方向旋轉浮點數  
  9.     private Drawable compass;// 圖片資源  
  10.       
  11.     //三個構造器  
  12.     public CompassView(Context context) {  
  13.         super(context);  
  14.         mDirection = 0.0f;// 默認不旋轉  
  15.         compass = null;  
  16.     }  
  17.   
  18.     public CompassView(Context context, AttributeSet attrs) {  
  19.         super(context, attrs);  
  20.         mDirection = 0.0f;  
  21.         compass = null;  
  22.     }  
  23.   
  24.     public CompassView(Context context, AttributeSet attrs, int defStyle) {  
  25.         super(context, attrs, defStyle);  
  26.         mDirection = 0.0f;  
  27.         compass = null;  
  28.     }  
  29.   
  30.     @Override  
  31.     protected void onDraw(Canvas canvas) {  
  32.         if (compass == null) {  
  33.             compass = getDrawable();// 獲取當前view的圖片資源  
  34.             compass.setBounds(0, 0, getWidth(), getHeight());// 圖片資源在view的位置，此處至關於充滿view  
  35.         }  
  36.   
  37.         canvas.save();  
  38.         canvas.rotate(mDirection, getWidth() / 2, getHeight() / 2);// 繞圖片中心點旋轉，  
  39.         compass.draw(canvas);// 把旋轉後的圖片畫在view上，即保持旋轉後的樣子  
  40.         canvas.restore();// 保存一下  
  41.     }  
  42.   
  43.     /** 
  44.      * 自定義更新方向的方法 
  45.      *  
  46.      * @param direction 
  47.      *            傳入的方向 
  48.      */  
  49.     public void updateDirection(float direction) {  
  50.         mDirection = direction;  
  51.         invalidate();// 從新刷新一下，更新方向  
  52.     }  
  53.   
  54. }  


接下來就只剩下一個Activity了，其實整體結構仍是很簡單的，CompassActivity.java：

[java] view plain copy
  1. /** 
  2.  * MainActivity 
  3.  *  
  4.  * @author way 
  5.  *  
  6.  */  
  7. public class CompassActivity extends Activity {  
  8.     private static final int EXIT_TIME = 2000;// 兩次按返回鍵的間隔判斷  
  9.     private final float MAX_ROATE_DEGREE = 1.0f;// 最多旋轉一週，即360°  
  10.     private SensorManager mSensorManager;// 傳感器管理對象  
  11.     private Sensor mOrientationSensor;// 傳感器對象  
  12.     private LocationManager mLocationManager;// 位置管理對象  
  13.     private String mLocationProvider;// 位置提供者名稱，GPS設備仍是網絡  
  14.     private float mDirection;// 當前浮點方向  
  15.     private float mTargetDirection;// 目標浮點方向  
  16.     private AccelerateInterpolator mInterpolator;// 動畫從開始到結束，變化率是一個加速的過程,就是一個動畫速率  
  17.     protected final Handler mHandler = new Handler();  
  18.     private boolean mStopDrawing;// 是否中止指南針旋轉的標誌位  
  19.     private boolean mChinease;// 系統當前是否使用中文  
  20.     private long firstExitTime = 0L;// 用來保存第一次按返回鍵的時間  
  21.   
  22.     View mCompassView;  
  23.     CompassView mPointer;// 指南針view  
  24.     TextView mLocationTextView;// 顯示位置的view  
  25.     LinearLayout mDirectionLayout;// 顯示方向（東南西北）的view  
  26.     LinearLayout mAngleLayout;// 顯示方向度數的view  
  27.   
  28.     // 這個是更新指南針旋轉的線程，handler的靈活使用，每20毫秒檢測方向變化值，對應更新指南針旋轉  
  29.     protected Runnable mCompassViewUpdater = new Runnable() {  
  30.         @Override  
  31.         public void run() {  
  32.             if (mPointer != null && !mStopDrawing) {  
  33.                 if (mDirection != mTargetDirection) {  
  34.   
  35.                     // calculate the short routine  
  36.                     float to = mTargetDirection;  
  37.                     if (to - mDirection > 180) {  
  38.                         to -= 360;  
  39.                     } else if (to - mDirection < -180) {  
  40.                         to += 360;  
  41.                     }  
  42.   
  43.                     // limit the max speed to MAX_ROTATE_DEGREE  
  44.                     float distance = to - mDirection;  
  45.                     if (Math.abs(distance) > MAX_ROATE_DEGREE) {  
  46.                         distance = distance > 0 ? MAX_ROATE_DEGREE  
  47.                                 : (-1.0f * MAX_ROATE_DEGREE);  
  48.                     }  
  49.   
  50.                     // need to slow down if the distance is short  
  51.                     mDirection = normalizeDegree(mDirection  
  52.                             + ((to - mDirection) * mInterpolator  
  53.                                     .getInterpolation(Math.abs(distance) > MAX_ROATE_DEGREE ? 0.4f  
  54.                                             : 0.3f)));// 用了一個加速動畫去旋轉圖片，很細緻  
  55.                     mPointer.updateDirection(mDirection);// 更新指南針旋轉  
  56.                 }  
  57.   
  58.                 updateDirection();// 更新方向值  
  59.   
  60.                 mHandler.postDelayed(mCompassViewUpdater, 20);// 20毫米後從新執行本身，比定時器好  
  61.             }  
  62.         }  
  63.     };  
  64.   
  65.     @Override  
  66.     protected void onCreate(Bundle savedInstanceState) {  
  67.         super.onCreate(savedInstanceState);  
  68.         setContentView(R.layout.main);  
  69.         initResources();// 初始化view  
  70.         initServices();// 初始化傳感器和位置服務  
  71.     }  
  72.   
  73.     @Override  
  74.     public void onBackPressed() {// 覆蓋返回鍵  
  75.         long curTime = System.currentTimeMillis();  
  76.         if (curTime - firstExitTime < EXIT_TIME) {// 兩次按返回鍵的時間小於2秒就退出應用  
  77.             finish();  
  78.         } else {  
  79.             Toast.makeText(this, R.string.exit_toast, Toast.LENGTH_SHORT)  
  80.                     .show();  
  81.             firstExitTime = curTime;  
  82.         }  
  83.     }  
  84.   
  85.     @Override  
  86.     protected void onResume() {// 在恢復的生命週期裏判斷、啓動位置更新服務和傳感器服務  
  87.         super.onResume();  
  88.         if (mLocationProvider != null) {  
  89.             updateLocation(mLocationManager  
  90.                     .getLastKnownLocation(mLocationProvider));  
  91.             mLocationManager.requestLocationUpdates(mLocationProvider, 2000,  
  92.                     10, mLocationListener);// 2秒或者距離變化10米時更新一次地理位置  
  93.         } else {  
  94.             mLocationTextView.setText(R.string.cannot_get_location);  
  95.         }  
  96.         if (mOrientationSensor != null) {  
  97.             mSensorManager.registerListener(mOrientationSensorEventListener,  
  98.                     mOrientationSensor, SensorManager.SENSOR_DELAY_GAME);  
  99.         } else {  
  100.             Toast.makeText(this, R.string.cannot_get_sensor, Toast.LENGTH_SHORT)  
  101.                     .show();  
  102.         }  
  103.         mStopDrawing = false;  
  104.         mHandler.postDelayed(mCompassViewUpdater, 20);// 20毫秒執行一次更新指南針圖片旋轉  
  105.     }  
  106.   
  107.     @Override  
  108.     protected void onPause() {// 在暫停的生命週期裏註銷傳感器服務和位置更新服務  
  109.         super.onPause();  
  110.         mStopDrawing = true;  
  111.         if (mOrientationSensor != null) {  
  112.             mSensorManager.unregisterListener(mOrientationSensorEventListener);  
  113.         }  
  114.         if (mLocationProvider != null) {  
  115.             mLocationManager.removeUpdates(mLocationListener);  
  116.         }  
  117.     }  
  118.   
  119.     // 初始化view  
  120.     private void initResources() {  
  121.         mDirection = 0.0f;// 初始化起始方向  
  122.         mTargetDirection = 0.0f;// 初始化目標方向  
  123.         mInterpolator = new AccelerateInterpolator();// 實例化加速動畫對象  
  124.         mStopDrawing = true;  
  125.         mChinease = TextUtils.equals(Locale.getDefault().getLanguage(), "zh");// 判斷系統當前使用的語言是否爲中文  
  126.   
  127.         mCompassView = findViewById(R.id.view_compass);// 其實是一個LinearLayout，裝指南針ImageView和位置TextView  
  128.         mPointer = (CompassView) findViewById(R.id.compass_pointer);// 自定義的指南針view  
  129.         mLocationTextView = (TextView) findViewById(R.id.textview_location);// 顯示位置信息的TextView  
  130.         mDirectionLayout = (LinearLayout) findViewById(R.id.layout_direction);// 頂部顯示方向名稱（東南西北）的LinearLayout  
  131.         mAngleLayout = (LinearLayout) findViewById(R.id.layout_angle);// 頂部顯示方向具體度數的LinearLayout  
  132.   
  133.         mPointer.setImageResource(mChinease ? R.drawable.compass_cn  
  134.                 : R.drawable.compass);// 若是系統使用中文，就用中文的指南針圖片  
  135.     }  
  136.   
  137.     // 初始化傳感器和位置服務  
  138.     private void initServices() {  
  139.         // sensor manager  
  140.         mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);  
  141.         mOrientationSensor = mSensorManager  
  142.                 .getDefaultSensor(Sensor.TYPE_ORIENTATION);  
  143.   
  144.         // location manager  
  145.         mLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);  
  146.         Criteria criteria = new Criteria();// 條件對象，即指定條件過濾得到LocationProvider  
  147.         criteria.setAccuracy(Criteria.ACCURACY_FINE);// 較高精度  
  148.         criteria.setAltitudeRequired(false);// 是否須要高度信息  
  149.         criteria.setBearingRequired(false);// 是否須要方向信息  
  150.         criteria.setCostAllowed(true);// 是否產生費用  
  151.         criteria.setPowerRequirement(Criteria.POWER_LOW);// 設置低電耗  
  152.         mLocationProvider = mLocationManager.getBestProvider(criteria, true);// 獲取條件最好的Provider  
  153.   
  154.     }  
  155.   
  156.     // 更新頂部方向顯示的方法  
  157.     private void updateDirection() {  
  158.         LayoutParams lp = new LayoutParams(LayoutParams.WRAP_CONTENT,  
  159.                 LayoutParams.WRAP_CONTENT);  
  160.         // 先移除layout中全部的view  
  161.         mDirectionLayout.removeAllViews();  
  162.         mAngleLayout.removeAllViews();  
  163.   
  164.         // 下面是根據mTargetDirection，做方向名稱圖片的處理  
  165.         ImageView east = null;  
  166.         ImageView west = null;  
  167.         ImageView south = null;  
  168.         ImageView north = null;  
  169.         float direction = normalizeDegree(mTargetDirection * -1.0f);  
  170.         if (direction > 22.5f && direction < 157.5f) {  
  171.             // east  
  172.             east = new ImageView(this);  
  173.             east.setImageResource(mChinease ? R.drawable.e_cn : R.drawable.e);  
  174.             east.setLayoutParams(lp);  
  175.         } else if (direction > 202.5f && direction < 337.5f) {  
  176.             // west  
  177.             west = new ImageView(this);  
  178.             west.setImageResource(mChinease ? R.drawable.w_cn : R.drawable.w);  
  179.             west.setLayoutParams(lp);  
  180.         }  
  181.   
  182.         if (direction > 112.5f && direction < 247.5f) {  
  183.             // south  
  184.             south = new ImageView(this);  
  185.             south.setImageResource(mChinease ? R.drawable.s_cn : R.drawable.s);  
  186.             south.setLayoutParams(lp);  
  187.         } else if (direction < 67.5 || direction > 292.5f) {  
  188.             // north  
  189.             north = new ImageView(this);  
  190.             north.setImageResource(mChinease ? R.drawable.n_cn : R.drawable.n);  
  191.             north.setLayoutParams(lp);  
  192.         }  
  193.         // 下面是根據系統使用語言，更換對應的語言圖片資源  
  194.         if (mChinease) {  
  195.             // east/west should be before north/south  
  196.             if (east != null) {  
  197.                 mDirectionLayout.addView(east);  
  198.             }  
  199.             if (west != null) {  
  200.                 mDirectionLayout.addView(west);  
  201.             }  
  202.             if (south != null) {  
  203.                 mDirectionLayout.addView(south);  
  204.             }  
  205.             if (north != null) {  
  206.                 mDirectionLayout.addView(north);  
  207.             }  
  208.         } else {  
  209.             // north/south should be before east/west  
  210.             if (south != null) {  
  211.                 mDirectionLayout.addView(south);  
  212.             }  
  213.             if (north != null) {  
  214.                 mDirectionLayout.addView(north);  
  215.             }  
  216.             if (east != null) {  
  217.                 mDirectionLayout.addView(east);  
  218.             }  
  219.             if (west != null) {  
  220.                 mDirectionLayout.addView(west);  
  221.             }  
  222.         }  
  223.         // 下面是根據方向度數顯示度數圖片數字  
  224.         int direction2 = (int) direction;  
  225.         boolean show = false;  
  226.         if (direction2 >= 100) {  
  227.             mAngleLayout.addView(getNumberImage(direction2 / 100));  
  228.             direction2 %= 100;  
  229.             show = true;  
  230.         }  
  231.         if (direction2 >= 10 || show) {  
  232.             mAngleLayout.addView(getNumberImage(direction2 / 10));  
  233.             direction2 %= 10;  
  234.         }  
  235.         mAngleLayout.addView(getNumberImage(direction2));  
  236.         // 下面是增長一個°的圖片  
  237.         ImageView degreeImageView = new ImageView(this);  
  238.         degreeImageView.setImageResource(R.drawable.degree);  
  239.         degreeImageView.setLayoutParams(lp);  
  240.         mAngleLayout.addView(degreeImageView);  
  241.     }  
  242.   
  243.     // 獲取方向度數對應的圖片，返回ImageView  
  244.     private ImageView getNumberImage(int number) {  
  245.         ImageView image = new ImageView(this);  
  246.         LayoutParams lp = new LayoutParams(LayoutParams.WRAP_CONTENT,  
  247.                 LayoutParams.WRAP_CONTENT);  
  248.         switch (number) {  
  249.         case 0:  
  250.             image.setImageResource(R.drawable.number_0);  
  251.             break;  
  252.         case 1:  
  253.             image.setImageResource(R.drawable.number_1);  
  254.             break;  
  255.         case 2:  
  256.             image.setImageResource(R.drawable.number_2);  
  257.             break;  
  258.         case 3:  
  259.             image.setImageResource(R.drawable.number_3);  
  260.             break;  
  261.         case 4:  
  262.             image.setImageResource(R.drawable.number_4);  
  263.             break;  
  264.         case 5:  
  265.             image.setImageResource(R.drawable.number_5);  
  266.             break;  
  267.         case 6:  
  268.             image.setImageResource(R.drawable.number_6);  
  269.             break;  
  270.         case 7:  
  271.             image.setImageResource(R.drawable.number_7);  
  272.             break;  
  273.         case 8:  
  274.             image.setImageResource(R.drawable.number_8);  
  275.             break;  
  276.         case 9:  
  277.             image.setImageResource(R.drawable.number_9);  
  278.             break;  
  279.         }  
  280.         image.setLayoutParams(lp);  
  281.         return image;  
  282.     }  
  283.   
  284.     // 更新位置顯示  
  285.     private void updateLocation(Location location) {  
  286.         if (location == null) {  
  287.             mLocationTextView.setText(R.string.getting_location);  
  288.         } else {  
  289.             StringBuilder sb = new StringBuilder();  
  290.             double latitude = location.getLatitude();  
  291.             double longitude = location.getLongitude();  
  292.   
  293.             if (latitude >= 0.0f) {  
  294.                 sb.append(getString(R.string.location_north,  
  295.                         getLocationString(latitude)));  
  296.             } else {  
  297.                 sb.append(getString(R.string.location_south,  
  298.                         getLocationString(-1.0 * latitude)));  
  299.             }  
  300.   
  301.             sb.append("    ");  
  302.   
  303.             if (longitude >= 0.0f) {  
  304.                 sb.append(getString(R.string.location_east,  
  305.                         getLocationString(longitude)));  
  306.             } else {  
  307.                 sb.append(getString(R.string.location_west,  
  308.                         getLocationString(-1.0 * longitude)));  
  309.             }  
  310.             mLocationTextView.setText(sb.toString());// 顯示經緯度，其實還能夠做反向編譯，顯示具體地址  
  311.         }  
  312.     }  
  313.   
  314.     // 把經緯度轉換成度分秒顯示  
  315.     private String getLocationString(double input) {  
  316.         int du = (int) input;  
  317.         int fen = (((int) ((input - du) * 3600))) / 60;  
  318.         int miao = (((int) ((input - du) * 3600))) % 60;  
  319.         return String.valueOf(du) + "°" + String.valueOf(fen) + "′"  
  320.                 + String.valueOf(miao) + "″";  
  321.     }  
  322.   
  323.     // 方向傳感器變化監聽  
  324.     private SensorEventListener mOrientationSensorEventListener = new SensorEventListener() {  
  325.   
  326.         @Override  
  327.         public void onSensorChanged(SensorEvent event) {  
  328.             float direction = event.values[0] * -1.0f;  
  329.             mTargetDirection = normalizeDegree(direction);// 賦值給全局變量，讓指南針旋轉  
  330.         }  
  331.   
  332.         @Override  
  333.         public void onAccuracyChanged(Sensor sensor, int accuracy) {  
  334.         }  
  335.     };  
  336.   
  337.     // 調整方向傳感器獲取的值  
  338.     private float normalizeDegree(float degree) {  
  339.         return (degree + 720) % 360;  
  340.     }  
  341.   
  342.     // 位置信息更新監聽  
  343.     LocationListener mLocationListener = new LocationListener() {  
  344.   
  345.         @Override  
  346.         public void onStatusChanged(String provider, int status, Bundle extras) {  
  347.             if (status != LocationProvider.OUT_OF_SERVICE) {  
  348.                 updateLocation(mLocationManager  
  349.                         .getLastKnownLocation(mLocationProvider));  
  350.             } else {  
  351.                 mLocationTextView.setText(R.string.cannot_get_location);  
  352.             }  
  353.         }  
  354.   
  355.         @Override  
  356.         public void onProviderEnabled(String provider) {  
  357.         }  
  358.   
  359.         @Override  
  360.         public void onProviderDisabled(String provider) {  
  361.         }  
  362.   
  363.         @Override  
  364.         public void onLocationChanged(Location location) {  
  365.             updateLocation(location);// 更新位置  
  366.         }  
  367.     };  
  368. }  

 

好了，核心代碼就這些了，其實思路仍是很簡單，最後，感謝各位看到文章最後，祝願各位程序猿們好好學習，每天向上！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程