time 
设为首页】【收藏本站
当前位置: 主页 > 电脑网络 > 操作系统 > 嵌入式 > Android > Android实现QQ手机管家小火箭桌面悬浮窗效果

Android实现QQ手机管家小火箭桌面悬浮窗效果

时间:2014-06-20 11:30 点击:4919次 字体:[ ]




记得我写的第一篇文章是模仿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()这个方法,它是用于判断小火箭是否已经拖动到火箭发射台上了。判断的方式当然也很简单,只需要对小火箭的边界和火箭发射台的边界进行检测,判断它们是否相交就行了。
 



本文地址 : http://www.fengfly.com/plus/view-215113-1.html
标签: Android
------分隔线----------------------------
最新评论 查看所有评论
发表评论 查看所有评论
请自觉遵守互联网相关的政策法规,严禁发布色情、暴力、反动的言论。
评价:
表情:
验证码: