Kivy PongApp 球以高速穿过桨

25-02-27 12

如果您对KivyPongApp球以高速穿过桨感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解KivyPongApp球以高速穿过桨的各种细节，此外还有关于181102Windows下安装kivy（

如果您对Kivy PongApp 球以高速穿过桨感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解Kivy PongApp 球以高速穿过桨的各种细节，此外还有关于181102 Windows下安装kivy（用python写APP）、@Controller 文件相关 @RequestMapping @PostMapping @PutMapping @DeleteMapping @PatchMapping、android.app.ActivityManager.RunningAppProcessInfo的实例源码、CMUÐ实现突破：机器狗点满敏捷值天赋，超高速穿越障碍，速度与安全兼备！的实用技巧。

本文目录一览：

Kivy PongApp 球以高速穿过桨
181102 Windows下安装kivy（用python写APP）
@Controller 文件相关 @RequestMapping @PostMapping @PutMapping @DeleteMapping @PatchMapping
android.app.ActivityManager.RunningAppProcessInfo的实例源码
CMUÐ实现突破：机器狗点满敏捷值天赋，超高速穿越障碍，速度与安全兼备！

Kivy PongApp 球以高速穿过桨

如何解决Kivy PongApp 球以高速穿过桨？

我是 python 和 kivy 的新手，当我注意到球与球拍碰撞 25 次后，它不会记录第 26 次碰撞，因此不会记录玩家的得分会增加。

我认为这个问题与沿 x 轴移动超过特定速度的速度有关，其中球的位置永远不会与桨的 x 位置相互作用。然而让我感到困惑的是，当将每次碰撞的速度增加从 1.1 更改为 1.2 时，分数增加前的最大碰撞次数从 11 到 18 次不等。

我的问题是，这个问题的根本原因是什么，我怎样才能确保无论速度如何，球总是会与球拍碰撞？

main.py:

public function store(Request $request)
{
    $confirmed = app(ConfirmPassword::class)(
        $this->guard,$request->user(),$request->input(''password'')
    );

    if ($confirmed) {
       // here is the problem ... no session with tokens 
       $request->session()->put(''auth.password_confirmed_at'',time());
    }

    return $confirmed
                ? app(PasswordConfirmedResponse::class)
                : app(FailedPasswordConfirmationResponse::class);
}

pong.kv：

from kivy.app import App
from kivy.uix.widget import Widget
from kivy.properties import (NumericProperty,ReferenceListProperty,ObjectProperty)
from kivy.vector import Vector
from kivy.clock import Clock
from random import randint

class PongPaddle(Widget):
    score = NumericProperty(0)

    def bounce_ball(self,ball):
        if self.collide_widget(ball):
            vx,vy = ball.veLocity
            offset = (ball.center_y - self.center_y) / (self.height / 2)
            bounced = Vector(-1 * vx,vy)
            vel = bounced * 3
            ball.veLocity = vel.x,vel.y + offset


class PongBall(Widget):

    # veLocity of the ball on x and y axis
    veLocity_x = NumericProperty(0)
    veLocity_y = NumericProperty(0)

    # referencelist property so we can use ball.veLocity as
    # a shorthand,just like e.g. w.pos for w.x and w.y
    veLocity = ReferenceListProperty(veLocity_x,veLocity_y)

    # ``move`` function will move the ball one step. This
    #  will be called in equal intervals to animate the ball
    def move(self):
        self.pos = Vector(*self.veLocity) + self.pos

class PongGame(Widget):
    ball = ObjectProperty(None)
    player1 = ObjectProperty(None)
    player2 = ObjectProperty(None)

    def serve_ball(self,vel=(4,0)):
        self.ball.center = self.center
        self.ball.veLocity = vel

    def update(self,dt):
        self.ball.move()

        #bounce off paddles
        self.player1.bounce_ball(self.ball)
        self.player2.bounce_ball(self.ball)

        # bounce off top and bottom
        if (self.ball.y < 0) or (self.ball.top > self.height):
            self.ball.veLocity_y *= -1

        # bounce off left and right to score point
        if self.ball.x < self.x:
            self.player2.score += 1
            self.serve_ball(vel=(4,0))
        if self.ball.x > self.width:
            self.player1.score += 1
            self.serve_ball(vel=(-4,0))

    def on_touch_move(self,touch):
        if touch.x < self.width / 3:
            self.player1.center_y = touch.y
        if touch.x > self.width - self.width / 3:
            self.player2.center_y = touch.y


class PongApp(App):
    def build(self):
        game = PongGame()
        game.serve_ball()
        Clock.schedule_interval(game.update,1.0/60.0)
        return game

if __name__ == ''__main__'':
    PongApp().run()

解决方法

这是简单碰撞算法的一个基本问题：在移动对象后每帧只检查一次碰撞，如果它们在该帧中相互移动，算法无法注意到。这个问题是众所周知的，例如这个问题的版本是在电脑游戏中经常可以设法穿墙的原因之一（尽管现在一般的游戏确实使用更复杂的算法，并且以更复杂的方式被欺骗）。>

一般来说，解决这个问题的方法是使用更好的碰撞检测算法。例如，对于两个球体，您可以计算出它们在该帧期间是否会相交，方法是在该帧的线性移动步骤中计算出它们中心点的最近点，并将该距离与它们的半径进行比较，看看是否他们会相撞。

有效地进行通用碰撞通常是一个难题，您可以根据要优化的内容进行各种权衡（例如，如果您想有效地处理许多对象的近似碰撞，您会遇到不同的问题，如果您想要精确处理少量形状复杂的对象）。 Kivy 的示例使用了一个简单的算法来避免使示例变得复杂，而不是因为它是一个好的解决方案。如果您真的很关心有效地进行碰撞，我建议您使用物理库来处理它，有各种带有 Python 接口的库。

181102 Windows下安装kivy（用python写APP）

了解到Instgram,知乎等APP是用python写的。我也决定学习用python写APP。这里我们需要安装kivy。

环境：win7，python3.6

安装方式：DOS命令窗口

注意事项：目前不支持python3.4及以上版本。如需安装3.5及以上版本，请通过安装文件手动安装。

参考kivy网址安装（全英文）：https://kivy.org/doc/stable/installation/installation-windows.html

1. 确保升级pip 和wheel

python -m pip install --upgrade pip wheel setuptools

2. 安装依赖包

python -m pip install docutils pygments pypiwin32 kivy.deps.sdl2 kivy.deps.glew python -m pip install kivy.deps.gstreamer

python -m pip install kivy.deps.angle　　\\python3.5需要安装此项

3. 安装kivy

python -m pip install kivy

4. 安装kivy示例

python -m pip install kivy_examples

5. 验证kivy安装

在python开发环境中，编辑如下代码：

1 from kivy.app import App
2 from kivy.uix.button import Button
3 
4 class TestApp(App):
5     def build(self):
6         return Button(text="hello")
7 
8 TextApp().run()

View Code

@Controller 文件相关 @RequestMapping @PostMapping @PutMapping @DeleteMapping @PatchMapping

https://blog.csdn.net/magi1201/article/details/82226289（copy）

最近学习看一些代码，发现对于发送请求这件事，有的地方用@RequestMapping，有的地方用@PostMapping，为了搞清楚区别，特意查了下spring 源代码，现在特此记录下。

@GetMapping用于将HTTP get请求映射到特定处理程序的方法注解
具体来说，@GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写。

@PostMapping用于将HTTP post请求映射到特定处理程序的方法注解
具体来说，@PostMapping是一个组合注解，是@RequestMapping(method = RequestMethod.POST)的缩写。

下面我们来看下@GetMapping的源码，可以对上面的两句释义给予充分的支撑。

/**
 * Annotation for mapping HTTP {@code GET} requests onto specific handler
 * methods.
 *
 * <p>Specifically, {@code @GetMapping} is a <em>composed annotation</em> that
 * acts as a shortcut for {@code @RequestMapping(method = RequestMethod.GET)}.
 *
 *
 * @author Sam Brannen
 * @since 4.3
 * @see PostMapping
 * @see PutMapping
 * @see DeleteMapping
 * @see PatchMapping
 * @see RequestMapping
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@RequestMapping(method = RequestMethod.GET)
public @interface GetMapping {
 
    /**
     * Alias for {@link RequestMapping#name}.
     */
    @AliasFor(annotation = RequestMapping.class)
    String name() default "";
 
    ...
 
}

上面代码中，最关键的是 @RequestMapping(method = RequestMethod.GET)，这行代码即说明@GetMapping就是@RequestMapping附加了请求方法。同时，可以看到@GetMapping这个注解是spring4.3版本引入，同时引入的还有@PostMapping、@PutMapping、@DeleteMapping和@PatchMapping，一共5个注解。

所以，一般情况下用@RequestMapping(method = RequestMethod. XXXX)即可。

android.app.ActivityManager.RunningAppProcessInfo的实例源码

项目：letv 文件：PushNotificationReceiver.java

@SuppressLint({"NewApi"})
public static boolean isAppOnForeground(Context mContext) {
    ActivityManager activityManager = (ActivityManager) mContext.getSystemService("activity");
    String packageName = mContext.getPackageName();
    LogInfo.log("PushReceiver","packageName =" + packageName);
    List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
    if (appProcesses == null) {
        LogInfo.log("PushReceiver","------appProcesses == null-----");
        return false;
    }
    for (RunningAppProcessInfo appProcess : appProcesses) {
        LogInfo.log("PushReceiver","------appProcess.processName =" + appProcess.processName);
        if (appProcess.processName.equals(packageName) && appProcess.importance == 100) {
            for (RunningTaskInfo rti : activityManager.getRunningTasks(100)) {
                if (!(rti == null || rti.baseActivity == null || mContext.getPackageName() == null || !mContext.getPackageName().equals(rti.baseActivity.getPackageName()) || VERSION.SDK_INT < 11)) {
                    activityManager.moveTaskToFront(rti.id,1);
                }
            }
            return true;
        }
    }
    return false;
}

项目：eazycore 文件：AppUtils.java

/**
 * whether this process is named with processName
 * 
 * @param context
 * @param processName
 * @return <ul>
 *         return whether this process is named with processName
 *         <li>if context is null,return false</li>
 *         <li>if {@link ActivityManager#getRunningAppProcesses()} is null,return false</li>
 *         <li>if one process of {@link ActivityManager#getRunningAppProcesses()} is equal to processName,return
 *         true,otherwise return false</li>
 *         </ul>
 */
public static boolean isNamedProcess(Context context,String processName) {
    if (context == null) {
        return false;
    }

    int pid = android.os.Process.myPid();
    ActivityManager manager = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningAppProcessInfo> processInfoList = manager.getRunningAppProcesses();
    if (ListUtils.isEmpty(processInfoList)) {
        return false;
    }

    for (RunningAppProcessInfo processInfo : processInfoList) {
        if (processInfo != null && processInfo.pid == pid
                && ObjectUtils.isEquals(processName,processInfo.processName)) {
            return true;
        }
    }
    return false;
}

项目：GitHub 文件：Utils.java

public static String getMyProcessName(Context context) {
    String processName = "";
    ActivityManager am = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningAppProcessInfo> infoList = am.getRunningAppProcesses();
    if (infoList == null) {
        throw new RuntimeException("getRunningAppProcesses() returns 'null'.");
    }
    for (RunningAppProcessInfo info : infoList) {
        try {
            if (info.pid == Process.myPid()) {
                processName = info.processName;
                break;
            }
        } catch (Exception ignored) {
        }
    }
    return processName;
}

项目：mobile-store 文件：fdroidApp.java

/**
 * Asks if the current process is "org.fdroid.fdroid:acra".
 * <p>
 * This is helpful for bailing out of the {@link fdroidApp#onCreate} method early,preventing
 * problems that arise from executing the code twice. This happens due to the `android:process`
 * statement in AndroidManifest.xml causes another process to be created to run
 * {@link org.fdroid.fdroid.acra.CrashReportActivity}. This was causing lots of things to be
 * started/run twice including {@link CleanCacheService} and {@link WifiStateChangeService}.
 * <p>
 * Note that it is not perfect,because some devices seem to not provide a list of running app
 * processes when asked. In such situations,F-Droid may regress to the behavIoUr where some
 * services may run twice and thus cause weirdness or slowness. However that is probably better
 * for end users than experiencing a deterministic crash every time F-Droid is started.
 */
private boolean isAcraProcess() {
    ActivityManager manager = (ActivityManager) this.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningAppProcessInfo> processes = manager.getRunningAppProcesses();
    if (processes == null) {
        return false;
    }

    int pid = android.os.Process.myPid();
    for (RunningAppProcessInfo processInfo : processes) {
        if (processInfo.pid == pid && ACRA_ID.equals(processInfo.processName)) {
            return true;
        }
    }

    return false;
}

项目：AssistantBySDK 文件：StopListennerActivity.java

private boolean isAppOnForeground() { 
    ActivityManager aManager=((ActivityManager)getSystemService(Context.ACTIVITY_SERVICE));
       List<RunningAppProcessInfo> appProcesses = aManager.getRunningAppProcesses(); 
       if (appProcesses == null) return false; 
       for (RunningAppProcessInfo appProcess : appProcesses) { 
           if (appProcess.processName.equals(getPackageName())){
                Log.e("StopListennerActivity","appProcess.importance="+appProcess.importance);
               // inRunningTasks(aManager);
                if(appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) { 
                    return true; 
                }else{
                    return false;
                }
           } 
       } 
       return false; 
}

项目：chromium-net-for-android 文件：ChromiumMultiDexInstaller.java

private static String getProcessName(Context context) {
    try {
        String currentProcessName = null;
        int pid = android.os.Process.myPid();

        ActivityManager manager =
                (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        for (RunningAppProcessInfo processInfo : manager.getRunningAppProcesses()) {
            if (processInfo.pid == pid) {
                currentProcessName = processInfo.processName;
                break;
            }
        }

        return currentProcessName;
    } catch (SecurityException ex) {
        return null;
    }
}

项目：NoticeDog 文件：AppMonitor.java

public List<App> getCurrentlyRunningMonitoredApps() {
    List<App> runningMonitoredApps = new ArrayList();
    List<RunningAppProcessInfo> procInfos = ((ActivityManager) this.context.getSystemService("activity")).getRunningAppProcesses();
    if (procInfos != null) {
        for (RunningAppProcessInfo procInfo : procInfos) {
            String processName = procInfo.processName;
            if (!shouldExcludeRunningApp(procInfo)) {
                for (App app : this.appsToMonitor) {
                    if (app.getAppPackageName() != null && app.getAppPackageName().equals(processName)) {
                        runningMonitoredApps.add(app);
                    }
                }
            }
        }
    }
    return runningMonitoredApps;
}

项目：NoticeDog 文件：AppMonitor.java

boolean shouldExcludeRunningApp(RunningAppProcessInfo procInfo) {
    try {
        int flags = RunningAppProcessInfo.class.getField("flags").getInt(procInfo);
        if (procInfo.importance != 100) {
            return true;
        }
        if ((flags & 2) == 2) {
            return true;
        }
        if ((flags & 4) == 0) {
            return true;
        }
        return false;
    } catch (NoSuchFieldException e) {
        return true;
    } catch (illegalaccessexception e2) {
        return true;
    }
}

项目：SmartChart 文件：AppUtils.java

/**
 * whether this process is named with processName
 *
 * @param context     上下文
 * @param processName 进程名
 * @return <ul>
 * return whether this process is named with processName
 * <li>if context is null,return false</li>
 * <li>if {@link ActivityManager#getRunningAppProcesses()} is null,* return false</li>
 * <li>if one process of
 * {@link ActivityManager#getRunningAppProcesses()} is equal to
 * processName,return true,otherwise return false</li>
 * </ul>
 */
public static boolean isNamedProcess(Context context,String processName) {
    if (context == null || TextUtils.isEmpty(processName)) {
        return false;
    }

    int pid = android.os.Process.myPid();
    ActivityManager manager = (ActivityManager) context
            .getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningAppProcessInfo> processInfoList = manager
            .getRunningAppProcesses();
    if (processInfoList == null) {
        return true;
    }

    for (RunningAppProcessInfo processInfo : manager
            .getRunningAppProcesses()) {
        if (processInfo.pid == pid
                && processName.equalsIgnoreCase(processInfo.processName)) {
            return true;
        }
    }
    return false;
}

项目：EazyBaseMVP 文件：AppUtils.java

/**
 * whether this process is named with processName
 * 
 * @param context
 * @param processName
 * @return <ul>
 *         return whether this process is named with processName
 *         <li>if context is null,processInfo.processName)) {
            return true;
        }
    }
    return false;
}

项目：AppVisibilityDetector 文件：AppVisibilityDetector.java

public static boolean checkIsMainProcess(Application app) {
    ActivityManager activityManager = (ActivityManager) app.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningAppProcessInfo> runningAppProcessInfoList = activityManager.getRunningAppProcesses();
    if (null == runningAppProcessInfoList) {
        return false;
    }

    String currProcessName = null;
    int currPid = android.os.Process.myPid();
    //find the process name
    for (RunningAppProcessInfo processInfo : runningAppProcessInfoList) {
        if (null != processInfo && processInfo.pid == currPid) {
            currProcessName = processInfo.processName;
        }
    }

    //is current process the main process
    if (!TextUtils.equals(currProcessName,app.getPackageName())) {
        return false;
    }

    return true;
}

项目：springreplugin 文件：PluginProcessMain.java

private static final void waitKilled(int pid) {
    for (int i = 0; i < 10; i++) {
        try {
            Thread.sleep(100,0);
        } catch (Throwable e) {
            //
        }
        //
        List<RunningAppProcessInfo> processes = AMSUtils.getRunningAppProcessesNoThrows(RePluginInternal.getAppContext());
        if (processes == null || processes.isEmpty()) {
            continue;
        }
        boolean found = false;
        for (RunningAppProcessInfo info : processes) {
            if (info.pid == pid) {
                found = true;
            }
        }
        if (!found) {
            return;
        }
    }
}

项目：Droidplugin 文件：IPluginManagerImpl.java

@Override
public boolean killBackgroundProcesses(String pluginPackageName) throws remoteexception {
    ActivityManager am = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningAppProcessInfo> infos = am.getRunningAppProcesses();
    boolean success = false;
    for (RunningAppProcessInfo info : infos) {
        if (info.pkgList != null) {
            String[] pkgListcopy = Arrays.copyOf(info.pkgList,info.pkgList.length);
            Arrays.sort(pkgListcopy);
            if (Arrays.binarySearch(pkgListcopy,pluginPackageName) >= 0 && info.pid != android.os.Process.myPid()) {
                Log.i(TAG,"killBackgroundProcesses(%s),pkgList=%s,pid=%s",pluginPackageName,Arrays.toString(info.pkgList),info.pid);
                android.os.Process.killProcess(info.pid);
                success = true;
            }
        }
    }
    return success;
}

项目：Droidplugin 文件：PluginProcessManager.java

public static String getCurrentProcessName(Context context) {
    if (context == null)
        return sCurrentProcessName;

    synchronized (sGetCurrentProcessNameLock) {
        if (sCurrentProcessName == null) {
            ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
            List<RunningAppProcessInfo> infos = activityManager.getRunningAppProcesses();
            if (infos == null)
                return null;

            for (RunningAppProcessInfo info : infos) {
                if (info.pid == android.os.Process.myPid()) {
                    sCurrentProcessName = info.processName;
                    return sCurrentProcessName;
                }
            }
        }
    }
    return sCurrentProcessName;
}

项目：Droidplugin 文件：MyActivityManagerService.java

private void doGc(RunningAppProcessInfo myInfo) {
    int activityCount = mRunningProcessList.getActivityCountByPid(myInfo.pid);
    int serviceCount = mRunningProcessList.getServiceCountByPid(myInfo.pid);
    int providerCount = mRunningProcessList.getProviderCountByPid(myInfo.pid);
    if (activityCount <= 0 && serviceCount <= 0 && providerCount <= 0) {
        //杀死空进程。
        Log.i(TAG,"doGc kill process(pid=%s,uid=%s processName=%s)",myInfo.pid,myInfo.uid,myInfo.processName);
        try {
            android.os.Process.killProcess(myInfo.pid);
        } catch (Throwable e) {
            Log.e(TAG,"error on killProcess",e);
        }
    } else if (activityCount <= 0 && serviceCount > 0 /*&& !mRunningProcessList.isPersistentApplication(myInfo.pid)*/) {
        List<String> names = mRunningProcessList.getStubServiceByPid(myInfo.pid);
        if (names != null && names.size() > 0) {
            for (String name : names) {
                Intent service = new Intent();
                service.setClassName(mHostContext.getPackageName(),name);
                AbstractServiceStub.startKillService(mHostContext,service);
                Log.i(TAG,uid=%s processName=%s) service=%s",myInfo.processName,service);
            }
        }
    }
}

项目：boohee_v5.6 文件：DeviceHelper.java

public boolean isMainProcess(Context context) {
    if (context == null) {
        return false;
    }
    Object obj;
    int myPid = Process.myPid();
    for (RunningAppProcessInfo runningAppProcessInfo : ((ActivityManager) context
            .getSystemService(ModelName.ACTIVITY)).getRunningAppProcesses()) {
        if (runningAppProcessInfo.pid == myPid) {
            obj = runningAppProcessInfo.processName;
            break;
        }
    }
    obj = null;
    return context.getPackageName().equals(obj);
}

项目：boohee_v5.6 文件：TinkerServiceInternals.java

public static boolean isTinkerPatchServiceRunning(Context context) {
    ActivityManager am = (ActivityManager) context.getSystemService(ModelName.ACTIVITY);
    String serverName = getTinkerPatchServiceName(context);
    if (serverName == null) {
        return false;
    }
    try {
        for (RunningAppProcessInfo appProcess : am.getRunningAppProcesses()) {
            if (appProcess.processName.equals(serverName)) {
                return true;
            }
        }
        return false;
    } catch (Exception e) {
        Log.e(TAG,"isTinkerPatchServiceRunning Exception: " + e.toString());
        return false;
    } catch (Error e2) {
        Log.e(TAG,"isTinkerPatchServiceRunning Error: " + e2.toString());
        return false;
    }
}

项目：boohee_v5.6 文件：l.java

static String I(Context context) {
    try {
        if (aR != null) {
            return aR;
        }
        int myPid = Process.myPid();
        for (RunningAppProcessInfo runningAppProcessInfo : ((ActivityManager) context
                .getSystemService(ModelName.ACTIVITY)).getRunningAppProcesses()) {
            if (runningAppProcessInfo.pid == myPid) {
                aR = runningAppProcessInfo.processName;
                break;
            }
        }
        return aR;
    } catch (Throwable th) {
    }
}

项目：yaacc-code 文件：MultiContentPlayer.java

private void discoverStartedActivityPid() {

        ActivityManager activityManager = (ActivityManager) getContext()
                .getSystemService(Context.ACTIVITY_SERVICE);
        List<RunningTaskInfo> services = activityManager
                .getRunningTasks(Integer.MAX_VALUE);
        List<RunningAppProcessInfo> apps = activityManager
                .getRunningAppProcesses();
        String packageName = services.get(0).topActivity.getPackageName(); // fist
                                                                            // Task
                                                                            // is
                                                                            // the
                                                                            // last
                                                                            // started
                                                                            // task
        for (int i = 0; i < apps.size(); i++) {
            if (apps.get(i).processName.equals(packageName)) {
                appPid = apps.get(i).pid;
                Log.d(getClass().getName(),"Found activity process: " + apps.get(i).processName
                                + " PID: " + appPid);
            }

        }
    }

项目：yaacc-code 文件：LocalThirdPartieMusicPlayer.java

private void discoverMusicActivityPid() {

    ActivityManager activityManager = (ActivityManager) getContext()
            .getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningTaskInfo> services = activityManager
            .getRunningTasks(Integer.MAX_VALUE);
    List<RunningAppProcessInfo> apps = activityManager.getRunningAppProcesses();
    String packageName = services.get(0).topActivity.getPackageName(); //fist Task is the last started task     
    for (int i = 0; i < apps.size(); i++) {
        if(apps.get(i).processName .equals(packageName)){
            musicAppPid = apps.get(i).pid;
            Log.d(getClass().getName(),"Found music activity process: " + apps.get(i).processName + " PID: " + musicAppPid);
        }

    }
}

项目：DroidpluginLibrary 文件：IPluginManagerImpl.java

@Override
public boolean killBackgroundProcesses(String pluginPackageName) throws remoteexception {
    ActivityManager am = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningAppProcessInfo> infos = am.getRunningAppProcesses();
    boolean success = false;
    for (RunningAppProcessInfo info : infos) {
        if (info.pkgList != null) {
            String[] pkgListcopy = Arrays.copyOf(info.pkgList,info.pid);
                android.os.Process.killProcess(info.pid);
                success = true;
            }
        }
    }
    return success;
}

项目：DroidpluginLibrary 文件：MyActivityManagerService.java

private void doGc(RunningAppProcessInfo myInfo) {
    int activityCount = mRunningProcessList.getActivityCountByPid(myInfo.pid);
    int serviceCount = mRunningProcessList.getServiceCountByPid(myInfo.pid);
    int providerCount = mRunningProcessList.getProviderCountByPid(myInfo.pid);
    if (activityCount <= 0 && serviceCount <= 0 && providerCount <= 0) {
        //杀死空进程。
        Log.i(TAG,myInfo.processName);
        android.os.Process.killProcess(myInfo.pid);
    } else if (activityCount <= 0 && serviceCount > 0 /*&& !mRunningProcessList.isPersistentApplication(myInfo.pid)*/) {
        List<String> names = mRunningProcessList.getStubServiceByPid(myInfo.pid);
        if (names != null && names.size() > 0) {
            for (String name : names) {
                Intent service = new Intent();
                service.setClassName(mHostContext.getPackageName(),service);
            }
        }
    }
}

项目：Android-sunmiLauncher 文件：ProcessUtils.java

/**
 * 根据包名判断应用在前台还是后台
 * 
 * @param context
 * @return
 */
public static boolean isBackground(Context context,String packageName) {
    ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
    for (RunningAppProcessInfo appProcess : appProcesses) {
        if (appProcess.processName.equals(packageName)) {
            if (appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
                Log.i("前台",appProcess.processName);
                return false;
            } else {
                Log.i("后台",appProcess.processName);
                return true;
            }
        }
    }
    return true;
}

项目：TAG 文件：AppUtils.java

/**
 * whether this process is named with processName
 * 
 * @param context
 * @param processName
 * @return <ul>
 *         return whether this process is named with processName
 *         <li>if context is null,processInfo.processName)) {
            return true;
        }
    }
    return false;
}

项目：ooooim_android 文件：CommonUtil.java

/**
 * 判断应用是否在前台显示
 *
 * @param context     上下文
 * @param packageName 包名
 * @return 返回true表示在前台显示
 */
public static boolean isAppOnForeground(Context context,String packageName) {
    if (packageName == null || context == null) {
        return false;
    }
    ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
    if (appProcesses == null) {
        return false;
    }
    for (RunningAppProcessInfo appProcess : appProcesses) {
        if (appProcess.processName.equals(packageName)
                && appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
            return true;
        }
    }
    return false;
}

项目：ooooim_android 文件：CommonUtil.java

/**
 * 判断某个应用是否正在运行
 *
 * @param context     上下文
 * @param packageName 包名
 * @return 正在运行返回true,否则返回false
 */
public static boolean isAppOnRunning(Context context,String packageName) {
    if (packageName == null || context == null) {
        return false;
    }
    ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
    if (appProcesses == null)
        return false;
    for (RunningAppProcessInfo appProcess : appProcesses) {
        if (appProcess.processName.equals(packageName)) {
            return true;
        }
    }
    return false;
}

项目：mobilesafe 文件：ProcessInfoProvider.java

/**
 * ɱ�����н���
 * @param ctx   �����Ļ���
 */
public static void killAll(Context ctx) {
    //1,��ȡactivityManager
    ActivityManager am = (ActivityManager) ctx.getSystemService(Context.ACTIVITY_SERVICE);
    //2,��ȡ�������н��̵ļ���
    List<RunningAppProcessInfo> runningAppProcesses = am.getRunningAppProcesses();
    //3,ѭ���������еĽ���,����ɱ��
    for (RunningAppProcessInfo info : runningAppProcesses) {
        //4,�����ֻ���ʿ����,�����Ľ��̶���Ҫȥɱ��
        if(info.processName.equals(ctx.getPackageName())){
            //���ƥ�������ֻ���ʿ,����Ҫ��������ѭ��,������һ��Ѱ,����ɱ������
            continue;
        }
        am.killBackgroundProcesses(info.processName);
    }
}

项目：NewsMe 文件：AndroidUtil.java

/**
 * 程序是否在前台运行
 * 
 * @return
 */
public static boolean isAppOnForeground(Context context) {
    try {
        ActivityManager activityManager = (ActivityManager) context
                .getApplicationContext().getSystemService(
                        Context.ACTIVITY_SERVICE);
        String packageName = context.getPackageName();
        List<RunningAppProcessInfo> appProcesses = activityManager
                .getRunningAppProcesses();
        if (appProcesses == null) {
            return false;
        }
        for (RunningAppProcessInfo appProcess : appProcesses) {
            // The name of the process that this object is associated with.
            if (appProcess.processName.equals(packageName)
                    && appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
                return true;
            }
        }
    } catch (Exception e) {
        e.printstacktrace();
        LogS.e(TAG,"isAppOnForeground exception!",e);
    }
    return false;
}

项目：Watcher 文件：MemoryMonitor.java

private double getRunningAppProcessInfo() {
    double memSize;

    if (mRunningAppProcessInfo != null) {
        return getMemSize(mRunningAppProcessInfo) / 1024;
    }

    // 通过调用 ActivityManager 的 getRunningAppProcesses() 方法获得系统里所有正在运行的进程
    List<RunningAppProcessInfo> appProcessList = mActivityManager
        .getRunningAppProcesses();
    for (RunningAppProcessInfo appProcessInfo : appProcessList) {
        // 进程名，默认是包名或者由属性 android：process="" 指定
        String processName = appProcessInfo.processName;
        memSize = getMemSize(appProcessInfo);
        if (processName.equals(mPackageName)) {
            mRunningAppProcessInfo = appProcessInfo;
            return memSize / 1024;
        }
    }

    return -1;
}

项目：react-native-pure-notification 文件：NotificationEventReceiver.java

private boolean applicationIsRunning(Context context) {
    ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.KITKAT_WATCH) {
        List<RunningAppProcessInfo> processInfos = activityManager.getRunningAppProcesses();
        for (RunningAppProcessInfo processInfo : processInfos) {
            if (processInfo.processName.equals(context.getApplicationContext().getPackageName())) {
                if (processInfo.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
                    for (String d: processInfo.pkgList) {
                        Log.v("ReactSystemNotification","NotificationEventReceiver: ok: " + d);
                        return true;
                    }
                }
            }
        }
    } else {
        List<ActivityManager.RunningTaskInfo> taskInfo = activityManager.getRunningTasks(1);
        ComponentName componentInfo = taskInfo.get(0).topActivity;
        if (componentInfo.getPackageName().equals(context.getPackageName())) {
            return true;
        }
    }

    return false;
}

项目：pet 文件：IPluginManagerImpl.java

@Override
public boolean killBackgroundProcesses(String pluginPackageName) throws remoteexception {
    ActivityManager am = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningAppProcessInfo> infos = am.getRunningAppProcesses();
    boolean success = false;
    for (RunningAppProcessInfo info : infos) {
        if (info.pkgList != null) {
            String[] pkgListcopy = Arrays.copyOf(info.pkgList,info.pid);
                android.os.Process.killProcess(info.pid);
                success = true;
            }
        }
    }
    return success;
}

项目：pet 文件：PluginProcessManager.java

public static String getCurrentProcessName(Context context) {
    if (context == null)
        return sCurrentProcessName;

    synchronized (sGetCurrentProcessNameLock) {
        if (sCurrentProcessName == null) {
            ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
            List<RunningAppProcessInfo> infos = activityManager.getRunningAppProcesses();
            if (infos == null)
                return null;

            for (RunningAppProcessInfo info : infos) {
                if (info.pid == android.os.Process.myPid()) {
                    sCurrentProcessName = info.processName;
                    return sCurrentProcessName;
                }
            }
        }
    }
    return sCurrentProcessName;
}

项目：pet 文件：MyActivityManagerService.java

private void doGc(RunningAppProcessInfo myInfo) {
    int activityCount = mRunningProcessList.getActivityCountByPid(myInfo.pid);
    int serviceCount = mRunningProcessList.getServiceCountByPid(myInfo.pid);
    int providerCount = mRunningProcessList.getProviderCountByPid(myInfo.pid);
    if (activityCount <= 0 && serviceCount <= 0 && providerCount <= 0) {
        //杀死空进程。
        Log.i(TAG,service);
            }
        }
    }
}

项目：SmartFace 文件：AppUtils.java

/**
 * whether this process is named with processName
 * 
 * @param context
 * @param processName
 * @return <ul>
 *         return whether this process is named with processName
 *         <li>if context is null,processInfo.processName)) {
            return true;
        }
    }
    return false;
}

项目：SinaVideoSdkDemo 文件：AndroidUtil.java

/**
 * 程序是否在前台运行
 * 
 * @return
 */
public static boolean isAppOnForeground(Context context) {
    try {
        ActivityManager activityManager = (ActivityManager) context
                .getApplicationContext().getSystemService(
                        Context.ACTIVITY_SERVICE);
        String packageName = context.getPackageName();
        List<RunningAppProcessInfo> appProcesses = activityManager
                .getRunningAppProcesses();
        if (appProcesses == null) {
            return false;
        }
        for (RunningAppProcessInfo appProcess : appProcesses) {
            // The name of the process that this object is associated with.
            if (appProcess.processName.equals(packageName)
                    && appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
                return true;
            }
        }
    } catch (Exception e) {
        e.printstacktrace();
        LogS.e(TAG,e);
    }
    return false;
}

项目：MVPFrames 文件：AppUtils.java

/**
 * 给定Context获取进程名
 *
 * @param context
 * @return
 */
public static String getProcessName(Context context) {
    ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    List<ActivityManager.RunningAppProcessInfo> runningApps = am.getRunningAppProcesses();
    if (runningApps == null) {
        return null;
    }
    for (ActivityManager.RunningAppProcessInfo proInfo : runningApps) {
        if (proInfo.pid == android.os.Process.myPid()) {
            if (proInfo.processName != null) {
                return proInfo.processName;
            }
        }
    }
    return null;
}

项目：assistance-platform-client-sdk-android 文件：RunningAppsReaderSensor.java

@Override
    protected void getData() {

        List<RunningServiceInfo> liServices = m_activityManager.getRunningServices(MAXIMUM_SERVICES);
        List<RunningAppProcessInfo> runningAppProcesses = m_activityManager.getRunningAppProcesses();
        // liTasks.get(0).

        // Account[] accounts = m_activityManager.getAccounts();
        // String[] strAccountTypes = new String[accounts.length];
        //
        // for (int i = 0; i < accounts.length; i++) {
        // strAccountTypes[i] = accounts[i].type;
        // }

        if (!liServices.isEmpty()) {
            // Todo: implement logic
            StringBuilder sb = new StringBuilder();
            // for (int i = 0; i < liProcesses.size() - 1; i++)
            // sb.append(liProcesses.get.type + ";");
            // sb.append(liProcesses[liProcesses.length - 1]);

//          SensorRunningServices sensor = new SensorRunningServices();
//          // sensor.setAccountTypes(sb.toString());
//          handleDBEntry(sensor);
        }
    }

项目：BigApp_discuz_Android 文件：ServiceHelper.java

public boolean isAppOnForeground() {
    // Returns a list of application processes that are running on the
    // device
    String packageName = context.getPackageName();
    ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
    if (appProcesses == null)
        return false;
    for (RunningAppProcessInfo appProcess : appProcesses) {
        // importance:
        // The relative importance level that the system places
        // on this process.
        // May be one of IMPORTANCE_FOREGROUND,IMPORTANCE_VISIBLE,// IMPORTANCE_SERVICE,IMPORTANCE_BACKGROUND,or IMPORTANCE_EMPTY.
        // These constants are numbered so that "more important" values are
        // always smaller than "less important" values.
        // processName:
        // The name of the process that this object is associated with.
        if (appProcess.processName.equals(packageName) && appProcess.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
            return true;
        }
    }
    return false;
}

项目：GOpenSource_AppKit_Android_AS 文件：NetUtils.java

public static boolean isBackground(Context context) {
    ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
    for (RunningAppProcessInfo appProcess : appProcesses) {
        if (appProcess.processName.equals(context.getPackageName())) {
            /*
             * BACKGROUND=400 EMPTY=500 FOREGROUND=100 GONE=1000
             * PERCEPTIBLE=130 SERVICE=300 ISIBLE=200
             */
            Log.i(context.getPackageName(),"此appimportace =" + appProcess.importance
                    + ",context.getClass().getName()=" + context.getClass().getName());
            if (appProcess.importance != RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
                Log.i(context.getPackageName(),"处于后台" + appProcess.processName);
                return true;
            } else {
                Log.i(context.getPackageName(),"处于前台" + appProcess.processName);
                return false;
            }
        }
    }
    return false;
}

项目：mobile-manager-tool 文件：StorageUtil.java

public static void cleanMemory(Context context){
    System.out.println("---> 清理前可用内存:"+getAvailMemory(context)+"MB");
    ActivityManager activityManager=(ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

    List<ActivityManager.RunningAppProcessInfo> processList = activityManager.getRunningAppProcesses();

    if (processList != null) {
        for (int i = 0; i < processList.size(); ++i) {
            RunningAppProcessInfo runningAppProcessInfo= processList.get(i);
            // 一般数值大于RunningAppProcessInfo.IMPORTANCE_SERVICE
            // 的进程即为长时间未使用进程或者空进程
            // 一般数值大于RunningAppProcessInfo.IMPORTANCE_VISIBLE
            // 的进程都是非可见进程,即在后台运行
            if (runningAppProcessInfo.importance > RunningAppProcessInfo.IMPORTANCE_VISIBLE) {
                String[] pkgList = runningAppProcessInfo.pkgList;
                for (int j = 0; j < pkgList.length; ++j) {
                    System.out.println("===> 正在清理:"+pkgList[j]);
                    activityManager.killBackgroundProcesses(pkgList[j]);
                }
            }

        }
    }
    System.out.println("---> 清理后可用内存:"+getAvailMemory(context)+"MB");
}

CMUÐ实现突破：机器狗点满敏捷值天赋，超高速穿越障碍，速度与安全兼备！

cmu和eth zurich团队合作开发了名为"敏捷但安全"（abs）的新框架，为四足机器人在复杂环境中实现高速运动提供了解决方案。该框架不仅在避免碰撞方面表现出高效能力，而且实现了前所未有的3.1毫秒极速运动。这一创新为足式机器人领域带来了新的进展。

在高速机器人运动领域，同时保持速度和安全性一直是一个巨大的挑战。然而，卡内基梅隆大学（CMU）和苏黎世联邦理工学院（ETH）的研究团队最近取得了突破性进展。他们开发的全新四足机器人算法不仅能够快速移动于复杂环境中，还能巧妙地避开障碍物，真正实现了“敏捷且安全”的目标。这项算法的创新之处在于它能够快速地识别和分析周围环境，并根据实时数据做出智能决策。通过使用先进的传感器和强大的计算能力，机器人能够准确地感知周围的障碍物，并通过调整步态和轨迹来避开它们。这项技术的成功应用将极大地推动高速机器人的发展