Android教程網
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> Android開發實例 >> Android實現QQ手機管家小火箭桌面懸浮窗效果

Android實現QQ手機管家小火箭桌面懸浮窗效果

編輯:Android開發實例

記得我寫的第一篇文章是模仿360手機衛士的桌面懸浮窗效果,相信用過QQ手機管家的朋友們都會知道它有一個小火箭加速的功能,將小火箭拖動到火箭發射台上發射就會出現一個火箭升空的動畫,那麼今天我們就來模仿著實現一下這個效果吧。

這次我們將代碼的重點放在火箭升空的效果上,因此簡單起見,就直接在模仿360手機衛士懸浮窗的那份代碼的基礎上繼續開發了,如果你還沒有看過那篇文章的話,建議先去閱讀http://www.fengfly.com/plus/view-215081-1.html 。

比起普通的桌面懸浮窗,現在我們需要在拖動懸浮窗的時候將懸浮窗變成一個小火箭,並且在屏幕的底部添加一個火箭發射台。那麼我們就從火箭發射台開始編寫吧,首先創建launcher.xml作為火箭發射台的布局文件,如下所示:

  1. <?xml version="1.0" encoding="UTF-8"?> 
  2. <LinearLayout 
  3.     xmlns:android="http://schemas.android.com/apk/res/android" 
  4.     android:layout_width="wrap_content" 
  5.     android:layout_height="wrap_content" 
  6.     android:orientation="vertical" 
  7.     > 
  8.       
  9.     <ImageView   
  10.         android:id="@+id/launcher_img" 
  11.         android:layout_width="200dp" 
  12.         android:layout_height="88dp" 
  13.         android:src="@drawable/launcher_bg_hold" 
  14.         /> 
  15.       
  16. </LinearLayout> 

可以看到,這裡的ImageView是用於顯示當前火箭發射台狀態的。我事先准備好了兩張圖片,一張是當小火箭未拖動到火箭發射台時顯示的,一張是當小火箭拖動到火箭發射台上時顯示的。

 

接下來創建RocketLauncher類,作為火箭發射台的View,代碼如下所示:

  1. public class RocketLauncher extends LinearLayout {  
  2.  
  3.     /**  
  4.      * 記錄火箭發射台的寬度  
  5.      */ 
  6.     public static int width;  
  7.  
  8.     /**  
  9.      * 記錄火箭發射台的高度  
  10.      */ 
  11.     public static int height;  
  12.  
  13.     /**  
  14.      * 火箭發射台的背景圖片  
  15.      */ 
  16.     private ImageView launcherImg;  
  17.  
  18.     public RocketLauncher(Context context) {  
  19.         super(context);  
  20.         LayoutInflater.from(context).inflate(R.layout.launcher, this);  
  21.         launcherImg = (ImageView) findViewById(R.id.launcher_img);  
  22.         width = launcherImg.getLayoutParams().width;  
  23.         height = launcherImg.getLayoutParams().height;  
  24.     }  
  25.  
  26.     /**  
  27.      * 更新火箭發射台的顯示狀態。如果小火箭被拖到火箭發射台上,就顯示發射。  
  28.      */ 
  29.     public void updateLauncherStatus(boolean isReadyToLaunch) {  
  30.         if (isReadyToLaunch) {  
  31.             launcherImg.setImageResource(R.drawable.launcher_bg_fire);  
  32.         } else {  
  33.             launcherImg.setImageResource(R.drawable.launcher_bg_hold);  
  34.         }  
  35.     }  
  36.  
  37. }  

RocketLauncher中的代碼還是非常簡單的,在構建方法中調用了LayoutInflater的inflate()方法來將launcher.xml這個布局文件加載進來,並獲取到了當前View的寬度和高度。在updateLauncherStatus()方法中會進行判斷,如果傳入的參數是true,就顯示小火箭即將發射的圖片,如果傳入的是false,就顯示將小火箭拖動到發射台的圖片。
 

 

新增的文件只有這兩個,剩下的就是要修改之前的代碼了。首先修改MyWindowManager中的代碼,如下所示:

  1. public class MyWindowManager {  
  2.  
  3.     /**  
  4.      * 小懸浮窗View的實例  
  5.      */ 
  6.     private static FloatWindowSmallView smallWindow;  
  7.  
  8.     /**  
  9.      * 大懸浮窗View的實例  
  10.      */ 
  11.     private static FloatWindowBigView bigWindow;  
  12.  
  13.     /**  
  14.      * 火箭發射台的實例  
  15.      */ 
  16.     private static RocketLauncher rocketLauncher;  
  17.  
  18.     /**  
  19.      * 小懸浮窗View的參數  
  20.      */ 
  21.     private static LayoutParams smallWindowParams;  
  22.  
  23.     /**  
  24.      * 大懸浮窗View的參數  
  25.      */ 
  26.     private static LayoutParams bigWindowParams;  
  27.  
  28.     /**  
  29.      * 火箭發射台的參數  
  30.      */ 
  31.     private static LayoutParams launcherParams;  
  32.  
  33.     /**  
  34.      * 用於控制在屏幕上添加或移除懸浮窗  
  35.      */ 
  36.     private static WindowManager mWindowManager;  
  37.  
  38.     /**  
  39.      * 用於獲取手機可用內存  
  40.      */ 
  41.     private static ActivityManager mActivityManager;  
  42.  
  43.     /**  
  44.      * 創建一個小懸浮窗。初始位置為屏幕的右部中間位置。  
  45.      */ 
  46.     public static void createSmallWindow(Context context) {  
  47.         WindowManager windowManager = getWindowManager(context);  
  48.         int screenWidth = windowManager.getDefaultDisplay().getWidth();  
  49.         int screenHeight = windowManager.getDefaultDisplay().getHeight();  
  50.         if (smallWindow == null) {  
  51.             smallWindow = new FloatWindowSmallView(context);  
  52.             if (smallWindowParams == null) {  
  53.                 smallWindowParams = new LayoutParams();  
  54.                 smallWindowParams.type = LayoutParams.TYPE_SYSTEM_ALERT;  
  55.                 smallWindowParams.format = PixelFormat.RGBA_8888;  
  56.                 smallWindowParams.flags = LayoutParams.FLAG_NOT_TOUCH_MODAL  
  57.                         | LayoutParams.FLAG_NOT_FOCUSABLE;  
  58.                 smallWindowParams.gravity = Gravity.LEFT | Gravity.TOP;  
  59.                 smallWindowParams.width = FloatWindowSmallView.windowViewWidth;  
  60.                 smallWindowParams.height = FloatWindowSmallView.windowViewHeight;  
  61.                 smallWindowParams.x = screenWidth;  
  62.                 smallWindowParams.y = screenHeight / 2;  
  63.             }  
  64.             smallWindow.setParams(smallWindowParams);  
  65.             windowManager.addView(smallWindow, smallWindowParams);  
  66.         }  
  67.     }  
  68.  
  69.     /**  
  70.      * 將小懸浮窗從屏幕上移除。  
  71.      */ 
  72.     public static void removeSmallWindow(Context context) {  
  73.         if (smallWindow != null) {  
  74.             WindowManager windowManager = getWindowManager(context);  
  75.             windowManager.removeView(smallWindow);  
  76.             smallWindow = null;  
  77.         }  
  78.     }  
  79.  
  80.     /**  
  81.      * 創建一個大懸浮窗。位置為屏幕正中間。  
  82.      */ 
  83.     public static void createBigWindow(Context context) {  
  84.         WindowManager windowManager = getWindowManager(context);  
  85.         int screenWidth = windowManager.getDefaultDisplay().getWidth();  
  86.         int screenHeight = windowManager.getDefaultDisplay().getHeight();  
  87.         if (bigWindow == null) {  
  88.             bigWindow = new FloatWindowBigView(context);  
  89.             if (bigWindowParams == null) {  
  90.                 bigWindowParams = new LayoutParams();  
  91.                 bigWindowParams.x = screenWidth / 2 
  92.                         - FloatWindowBigView.viewWidth / 2;  
  93.                 bigWindowParams.y = screenHeight / 2 
  94.                         - FloatWindowBigView.viewHeight / 2;  
  95.                 bigWindowParams.type = LayoutParams.TYPE_PHONE;  
  96.                 bigWindowParams.format = PixelFormat.RGBA_8888;  
  97.                 bigWindowParams.gravity = Gravity.LEFT | Gravity.TOP;  
  98.                 bigWindowParams.width = FloatWindowBigView.viewWidth;  
  99.                 bigWindowParams.height = FloatWindowBigView.viewHeight;  
  100.             }  
  101.             windowManager.addView(bigWindow, bigWindowParams);  
  102.         }  
  103.     }  
  104.  
  105.     /**  
  106.      * 將大懸浮窗從屏幕上移除。  
  107.      */ 
  108.     public static void removeBigWindow(Context context) {  
  109.         if (bigWindow != null) {  
  110.             WindowManager windowManager = getWindowManager(context);  
  111.             windowManager.removeView(bigWindow);  
  112.             bigWindow = null;  
  113.         }  
  114.     }  
  115.  
  116.     /**  
  117.      * 創建一個火箭發射台,位置為屏幕底部。  
  118.      */ 
  119.     public static void createLauncher(Context context) {  
  120.         WindowManager windowManager = getWindowManager(context);  
  121.         int screenWidth = windowManager.getDefaultDisplay().getWidth();  
  122.         int screenHeight = windowManager.getDefaultDisplay().getHeight();  
  123.         if (rocketLauncher == null) {  
  124.             rocketLauncher = new RocketLauncher(context);  
  125.             if (launcherParams == null) {  
  126.                 launcherParams = new LayoutParams();  
  127.                 launcherParams.x = screenWidth / 2 - RocketLauncher.width / 2;  
  128.                 launcherParams.y = screenHeight - RocketLauncher.height;  
  129.                 launcherParams.type = LayoutParams.TYPE_PHONE;  
  130.                 launcherParams.format = PixelFormat.RGBA_8888;  
  131.                 launcherParams.gravity = Gravity.LEFT | Gravity.TOP;  
  132.                 launcherParams.width = RocketLauncher.width;  
  133.                 launcherParams.height = RocketLauncher.height;  
  134.             }  
  135.             windowManager.addView(rocketLauncher, launcherParams);  
  136.         }  
  137.     }  
  138.  
  139.     /**  
  140.      * 將火箭發射台從屏幕上移除。  
  141.      */ 
  142.     public static void removeLauncher(Context context) {  
  143.         if (rocketLauncher != null) {  
  144.             WindowManager windowManager = getWindowManager(context);  
  145.             windowManager.removeView(rocketLauncher);  
  146.             rocketLauncher = null;  
  147.         }  
  148.     }  
  149.  
  150.     /**  
  151.      * 更新火箭發射台的顯示狀態。  
  152.      */ 
  153.     public static void updateLauncher() {  
  154.         if (rocketLauncher != null) {  
  155.             rocketLauncher.updateLauncherStatus(isReadyToLaunch());  
  156.         }  
  157.     }  
  158.  
  159.     /**  
  160.      * 更新小懸浮窗的TextView上的數據,顯示內存使用的百分比。  
  161.      *   
  162.      * @param context  
  163.      *            可傳入應用程序上下文。  
  164.      */ 
  165.     public static void updateUsedPercent(Context context) {  
  166.         if (smallWindow != null) {  
  167.             TextView percentView = (TextView) smallWindow  
  168.                     .findViewById(R.id.percent);  
  169.             percentView.setText(getUsedPercentValue(context));  
  170.         }  
  171.     }  
  172.  
  173.     /**  
  174.      * 是否有懸浮窗(包括小懸浮窗和大懸浮窗)顯示在屏幕上。  
  175.      *   
  176.      * @return 有懸浮窗顯示在桌面上返回true,沒有的話返回false。  
  177.      */ 
  178.     public static boolean isWindowShowing() {  
  179.         return smallWindow != null || bigWindow != null;  
  180.     }  
  181.  
  182.     /**  
  183.      * 判斷小火箭是否准備好發射了。  
  184.      *   
  185.      * @return 當火箭被發到發射台上返回true,否則返回false。  
  186.      */ 
  187.     public static boolean isReadyToLaunch() {  
  188.         if ((smallWindowParams.x > launcherParams.x && smallWindowParams.x  
  189.                 + smallWindowParams.width < launcherParams.x  
  190.                 + launcherParams.width)  
  191.                 && (smallWindowParams.y + smallWindowParams.height > launcherParams.y)) {  
  192.             return true;  
  193.         }  
  194.         return false;  
  195.     }  
  196.  
  197.     /**  
  198.      * 如果WindowManager還未創建,則創建一個新的WindowManager返回。否則返回當前已創建的WindowManager。  
  199.      *   
  200.      * @param context  
  201.      *            必須為應用程序的Context.  
  202.      * @return WindowManager的實例,用於控制在屏幕上添加或移除懸浮窗。  
  203.      */ 
  204.     private static WindowManager getWindowManager(Context context) {  
  205.         if (mWindowManager == null) {  
  206.             mWindowManager = (WindowManager) context  
  207.                     .getSystemService(Context.WINDOW_SERVICE);  
  208.         }  
  209.         return mWindowManager;  
  210.     }  
  211.  
  212.     /**  
  213.      * 如果ActivityManager還未創建,則創建一個新的ActivityManager返回。否則返回當前已創建的ActivityManager。  
  214.      *   
  215.      * @param context  
  216.      *            可傳入應用程序上下文。  
  217.      * @return ActivityManager的實例,用於獲取手機可用內存。  
  218.      */ 
  219.     private static ActivityManager getActivityManager(Context context) {  
  220.         if (mActivityManager == null) {  
  221.             mActivityManager = (ActivityManager) context  
  222.                     .getSystemService(Context.ACTIVITY_SERVICE);  
  223.         }  
  224.         return mActivityManager;  
  225.     }  
  226.  
  227.     /**  
  228.      * 計算已使用內存的百分比,並返回。  
  229.      *   
  230.      * @param context  
  231.      *            可傳入應用程序上下文。  
  232.      * @return 已使用內存的百分比,以字符串形式返回。  
  233.      */ 
  234.     public static String getUsedPercentValue(Context context) {  
  235.         String dir = "/proc/meminfo";  
  236.         try {  
  237.             FileReader fr = new FileReader(dir);  
  238.             BufferedReader br = new BufferedReader(fr, 2048);  
  239.             String memoryLine = br.readLine();  
  240.             String subMemoryLine = memoryLine.substring(memoryLine  
  241.                     .indexOf("MemTotal:"));  
  242.             br.close();  
  243.             long totalMemorySize = Integer.parseInt(subMemoryLine.replaceAll(  
  244.                     "\D+", ""));  
  245.             long availableSize = getAvailableMemory(context) / 1024;  
  246.             int percent = (int) ((totalMemorySize - availableSize)  
  247.                     / (float) totalMemorySize * 100);  
  248.             return percent + "%";  
  249.         } catch (IOException e) {  
  250.             e.printStackTrace();  
  251.         }  
  252.         return "懸浮窗";  
  253.     }  
  254.  
  255.     /**  
  256.      * 獲取當前可用內存,返回數據以字節為單位。  
  257.      *   
  258.      * @param context  
  259.      *            可傳入應用程序上下文。  
  260.      * @return 當前可用內存。  
  261.      */ 
  262.     private static long getAvailableMemory(Context context) {  
  263.         ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();  
  264.         getActivityManager(context).getMemoryInfo(mi);  
  265.         return mi.availMem;  
  266.     }  
  267.  
  268. }  

MyWindowManager是所有桌面懸浮窗的管理器,這裡我們主要添加了createLauncher()、removeLauncher()和updateLauncher()這幾個方法,分別用於創建、移除、以及更新火箭發射台懸浮窗。另外還添加了isReadyToLaunch()這個方法,它是用於判斷小火箭是否已經拖動到火箭發射台上了。判斷的方式當然也很簡單,只需要對小火箭的邊界和火箭發射台的邊界進行檢測,判斷它們是否相交就行了。
 

 

接下來還需要修改FloatWindowSmallView中的代碼,當手指拖動懸浮窗的時候要將它變成小火箭,如下所示:

  1. public class FloatWindowSmallView extends LinearLayout {  
  2.  
  3.     /**  
  4.      * 記錄小懸浮窗的寬度  
  5.      */ 
  6.     public static int windowViewWidth;  
  7.  
  8.     /**  
  9.      * 記錄小懸浮窗的高度  
  10.      */ 
  11.     public static int windowViewHeight;  
  12.  
  13.     /**  
  14.      * 記錄系統狀態欄的高度  
  15.      */ 
  16.     private static int statusBarHeight;  
  17.  
  18.     /**  
  19.      * 用於更新小懸浮窗的位置  
  20.      */ 
  21.     private WindowManager windowManager;  
  22.  
  23.     /**  
  24.      * 小懸浮窗的布局  
  25.      */ 
  26.     private LinearLayout smallWindowLayout;  
  27.  
  28.     /**  
  29.      * 小火箭控件  
  30.      */ 
  31.     private ImageView rocketImg;  
  32.  
  33.     /**  
  34.      * 小懸浮窗的參數  
  35.      */ 
  36.     private WindowManager.LayoutParams mParams;  
  37.  
  38.     /**  
  39.      * 記錄當前手指位置在屏幕上的橫坐標值  
  40.      */ 
  41.     private float xInScreen;  
  42.  
  43.     /**  
  44.      * 記錄當前手指位置在屏幕上的縱坐標值  
  45.      */ 
  46.     private float yInScreen;  
  47.  
  48.     /**  
  49.      * 記錄手指按下時在屏幕上的橫坐標的值  
  50.      */ 
  51.     private float xDownInScreen;  
  52.  
  53.     /**  
  54.      * 記錄手指按下時在屏幕上的縱坐標的值  
  55.      */ 
  56.     private float yDownInScreen;  
  57.  
  58.     /**  
  59.      * 記錄手指按下時在小懸浮窗的View上的橫坐標的值  
  60.      */ 
  61.     private float xInView;  
  62.  
  63.     /**  
  64.      * 記錄手指按下時在小懸浮窗的View上的縱坐標的值  
  65.      */ 
  66.     private float yInView;  
  67.  
  68.     /**  
  69.      * 記錄小火箭的寬度  
  70.      */ 
  71.     private int rocketWidth;  
  72.  
  73.     /**  
  74.      * 記錄小火箭的高度  
  75.      */ 
  76.     private int rocketHeight;  
  77.  
  78.     /**  
  79.      * 記錄當前手指是否按下  
  80.      */ 
  81.     private boolean isPressed;  
  82.  
  83.     public FloatWindowSmallView(Context context) {  
  84.         super(context);  
  85.         windowManager = (WindowManager) context  
  86.                 .getSystemService(Context.WINDOW_SERVICE);  
  87.         LayoutInflater.from(context).inflate(R.layout.float_window_small, this);  
  88.         smallWindowLayout = (LinearLayout) findViewById(R.id.small_window_layout);  
  89.         windowViewWidth = smallWindowLayout.getLayoutParams().width;  
  90.         windowViewHeight = smallWindowLayout.getLayoutParams().height;  
  91.         rocketImg = (ImageView) findViewById(R.id.rocket_img);  
  92.         rocketWidth = rocketImg.getLayoutParams().width;  
  93.         rocketHeight = rocketImg.getLayoutParams().height;  
  94.         TextView percentView = (TextView) findViewById(R.id.percent);  
  95.         percentView.setText(MyWindowManager.getUsedPercentValue(context));  
  96.     }  
  97.  
  98.     @Override 
  99.     public boolean onTouchEvent(MotionEvent event) {  
  100.         switch (event.getAction()) {  
  101.         case MotionEvent.ACTION_DOWN:  
  102.             isPressed = true;  
  103.             // 手指按下時記錄必要數據,縱坐標的值都需要減去狀態欄高度  
  104.             xInView = event.getX();  
  105.             yInView = event.getY();  
  106.             xDownInScreen = event.getRawX();  
  107.             yDownInScreen = event.getRawY() - getStatusBarHeight();  
  108.             xInScreen = event.getRawX();  
  109.             yInScreen = event.getRawY() - getStatusBarHeight();  
  110.             break;  
  111.         case MotionEvent.ACTION_MOVE:  
  112.             xInScreen = event.getRawX();  
  113.             yInScreen = event.getRawY() - getStatusBarHeight();  
  114.             // 手指移動的時候更新小懸浮窗的狀態和位置  
  115.             updateViewStatus();  
  116.             updateViewPosition();  
  117.             break;  
  118.         case MotionEvent.ACTION_UP:  
  119.             isPressed = false;  
  120.             if (MyWindowManager.isReadyToLaunch()) {  
  121.                 launchRocket();  
  122.             } else {  
  123.                 updateViewStatus();  
  124.                 // 如果手指離開屏幕時,xDownInScreen和xInScreen相等,且yDownInScreen和yInScreen相等,則視為觸發了單擊事件。  
  125.                 If (xDownInScreen == xInScreen && yDownInScreen == yInScreen) {  
  126.                     openBigWindow();  
  127.                 }  
  128.             }  
  129.             break;  
  130.         default:  
  131.             break;  
  132.         }  
  133.         return true;  
  134.     }  
  135.  
  136.     /**  
  137.      * 將小懸浮窗的參數傳入,用於更新小懸浮窗的位置。  
  138.      *   
  139.      * @param params  
  140.      *            小懸浮窗的參數  
  141.      */ 
  142.     public void setParams(WindowManager.LayoutParams params) {  
  143.         mParams = params;  
  144.     }  
  145.  
  146.     /**  
  147.      * 用於發射小火箭。  
  148.      */ 
  149.     private void launchRocket() {  
  150.         MyWindowManager.removeLauncher(getContext());  
  151.         new LaunchTask().execute();  
  152.     }  
  153.  
  154.     /**  
  155.      * 更新小懸浮窗在屏幕中的位置。  
  156.      */ 
  157.     private void updateViewPosition() {  
  158.         mParams.x = (int) (xInScreen - xInView);  
  159.         mParams.y = (int) (yInScreen - yInView);  
  160.         windowManager.updateViewLayout(this, mParams);  
  161.         MyWindowManager.updateLauncher();  
  162.     }  
  163.  
  164.     /**  
  165.      * 更新View的顯示狀態,判斷是顯示懸浮窗還是小火箭。  
  166.      */ 
  167.     private void updateViewStatus() {  
  168.         if (isPressed && rocketImg.getVisibility() != View.VISIBLE) {  
  169.             mParams.width = rocketWidth;  
  170.             mParams.height = rocketHeight;  
  171.             windowManager.updateViewLayout(this, mParams);  
  172.             smallWindowLayout.setVisibility(View.GONE);  
  173.             rocketImg.setVisibility(View.VISIBLE);  
  174.             MyWindowManager.createLauncher(getContext());  
  175.         } else if (!isPressed) {  
  176.             mParams.width = windowViewWidth;  
  177.             mParams.height = windowViewHeight;  
  178.             windowManager.updateViewLayout(this, mParams);  
  179.             smallWindowLayout.setVisibility(View.VISIBLE);  
  180.             rocketImg.setVisibility(View.GONE);  
  181.             MyWindowManager.removeLauncher(getContext());  
  182.         }  
  183.     }  
  184.  
  185.     /**  
  186.      * 打開大懸浮窗,同時關閉小懸浮窗。  
  187.      */ 
  188.     private void openBigWindow() {  
  189.         MyWindowManager.createBigWindow(getContext());  
  190.         MyWindowManager.removeSmallWindow(getContext());  
  191.     }  
  192.  
  193.     /**  
  194.      * 用於獲取狀態欄的高度。  
  195.      *   
  196.      * @return 返回狀態欄高度的像素值。  
  197.      */ 
  198.     private int getStatusBarHeight() {  
  199.         if (statusBarHeight == 0) {  
  200.             try {  
  201.                 Class<?> c = Class.forName("com.android.internal.R$dimen");  
  202.                 Object o = c.newInstance();  
  203.                 Field field = c.getField("status_bar_height");  
  204.                 int x = (Integer) field.get(o);  
  205.                 statusBarHeight = getResources().getDimensionPixelSize(x);  
  206.             } catch (Exception e) {  
  207.                 e.printStackTrace();  
  208.             }  
  209.         }  
  210.         return statusBarHeight;  
  211.     }  
  212.  
  213.     /**  
  214.      * 開始執行發射小火箭的任務。  
  215.      *   
  216.      * @author guolin  
  217.      */ 
  218.     class LaunchTask extends AsyncTask<Void, Void, Void> {  
  219.  
  220.         @Override 
  221.         protected Void doInBackground(Void… params) {  
  222.             // 在這裡對小火箭的位置進行改變,從而產生火箭升空的效果  
  223.             while (mParams.y > 0) {  
  224.                 mParams.y = mParams.y - 10;  
  225.                 publishProgress();  
  226.                 try {  
  227.                     Thread.sleep(8);  
  228.                 } catch (InterruptedException e) {  
  229.                     e.printStackTrace();  
  230.                 }  
  231.             }  
  232.             return null;  
  233.         }  
  234.  
  235.         @Override 
  236.         protected void onProgressUpdate(Void… values) {  
  237.             windowManager.updateViewLayout(FloatWindowSmallView.this, mParams);  
  238.         }  
  239.  
  240.         @Override 
  241.         protected void onPostExecute(Void result) {  
  242.             // 火箭升空結束後,回歸到懸浮窗狀態  
  243.             updateViewStatus();  
  244.             mParams.x = (int) (xDownInScreen - xInView);  
  245.             mParams.y = (int) (yDownInScreen - yInView);  
  246.             windowManager.updateViewLayout(FloatWindowSmallView.this, mParams);  
  247.         }  
  248.  
  249.     }  
  250.  
  251. }  

這裡在代碼中添加了一個isPressed標識位,用於判斷用戶是否正在拖動懸浮窗。當拖動的時候就調用updateViewStatus()方法來更新懸浮窗的顯示狀態,這時懸浮窗就會變成一個小火箭。然後當手指離開屏幕的時候,也會調用updateViewStatus()方法,這時發現isPressed為false,就會將懸浮窗重新顯示出來。

 

同時,當手指離開屏幕的時候,還會調用MyWindowManager的isReadyToLaunch()方法來判斷小火箭是否被拖動到火箭發射台上了,如果為true,就會觸發火箭升空的動畫效果。火箭升空的動畫實現是寫在LaunchTask這個任務裡的,可以看到,這裡會在doInBackground()方法中執行耗時邏輯,將小火箭的縱坐標不斷減小,以讓它實現上升的效果。當縱坐標減小到0的時候,火箭升空的動畫就結束了,然後在onPostExecute()方法中重新將懸浮窗顯示出來。

另外,在AndroidManifest.xml文件中記得要聲明兩個權限,如下所示:

  1. <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" /> 
  2. <uses-permission android:name="android.permission.GET_TASKS" /> 

代碼就只有這麼多,接下來我們運行一下看看效果吧。在主界面點擊Start Float Window按鈕可以開啟懸浮窗並回到桌面,然後拖動懸浮窗後就會變成小火箭的狀態,將它拖動到屏幕底部火箭發射台上,然後放手,小火箭就會騰空而起了,如下圖所示:
 

源碼下載,請點擊這裡

 

  1. 上一頁:
  2. 下一頁:
熱門文章
閱讀排行版
Copyright © Android教程網 All Rights Reserved