import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
@Test
public void testValues() {
    StorableActivityFence fence = StorableActivityFence.starting(
            DetectedActivityFence.IN_VEHICLE, DetectedActivityFence.RUNNING);
    int[] startActivities = {DetectedActivityFence.IN_VEHICLE, DetectedActivityFence.RUNNING};
    assertThat(fence.getType(), Matchers.is(StorableFence.Type.ACTIVITY));
    assertThat(fence.getActivityTypes(), is(startActivities));
    assertThat(fence.getTransitionType(), is(StorableActivityFence.START_TYPE));

    fence = StorableActivityFence.stopping(
            DetectedActivityFence.ON_BICYCLE, DetectedActivityFence.WALKING);
    int[] stopActivities = {DetectedActivityFence.ON_BICYCLE, DetectedActivityFence.WALKING};
    assertThat(fence.getType(), Matchers.is(StorableFence.Type.ACTIVITY));
    assertThat(fence.getActivityTypes(), is(stopActivities));
    assertThat(fence.getTransitionType(), is(StorableActivityFence.STOP_TYPE));

    fence = StorableActivityFence.during(
            DetectedActivityFence.ON_FOOT, DetectedActivityFence.STILL, DetectedActivityFence.UNKNOWN);
    int[] duringActivities = {DetectedActivityFence.ON_FOOT, DetectedActivityFence.STILL, DetectedActivityFence.UNKNOWN};
    assertThat(fence.getType(), Matchers.is(StorableFence.Type.ACTIVITY));
    assertThat(fence.getActivityTypes(), is(duringActivities));
    assertThat(fence.getTransitionType(), is(StorableActivityFence.DURING_TYPE));
}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
private void addHeadphoneAndLocationFence() {
        Intent intent = new Intent(MY_FENCE_RECEIVER_ACTION);
        PendingIntent mFencePendingIntent = PendingIntent.getBroadcast(FenceActivity.this,
                10001,
                intent,
                0);

        AwarenessFence headphoneFence = HeadphoneFence.during(HeadphoneState.PLUGGED_IN);
        AwarenessFence activityFence = DetectedActivityFence.during(DetectedActivityFence.WALKING);
        AwarenessFence jointFence = AwarenessFence.and(headphoneFence, activityFence);
        Awareness.FenceApi.updateFences(
                mGoogleApiClient,
                new FenceUpdateRequest.Builder()
                        .addFence(HEADPHONE_AND_WALKING_FENCE_KEY,
                                jointFence, mFencePendingIntent)
                        .build())
                .setResultCallback(new ResultCallback<Status>() {
                    @Override
                    public void onResult(@NonNull Status status) {
                        if (status.isSuccess()) {
                            Log.i(TAG, "Headphones AND Walking Fence was successfully registered.");
                        } else {
                            Log.e(TAG, "Headphones AND Walking Fence could not be registered: " + status);
                        }
                    }
                });
}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
@Override
    protected void provide() {
        Thread thread = Thread.currentThread();
        Thread.UncaughtExceptionHandler wrapped = thread.getUncaughtExceptionHandler();
        if (!(wrapped instanceof GoogleApiFixUncaughtExceptionHandler)) {
            GoogleApiFixUncaughtExceptionHandler handler = new GoogleApiFixUncaughtExceptionHandler(wrapped);
            thread.setUncaughtExceptionHandler(handler);
        }
//        Thread thread = Thread.currentThread();
//        thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
//            @Override
//            public void uncaughtException(Thread thread, Throwable throwable) {
//                System.out.println(thread.getName() + " throws exception: " + throwable);
//            }
//        });

            client = new GoogleApiClient.Builder(getContext())                              //Establish Connection
                    .addApi(Awareness.API)
                    .build();
            client.connect();
            walkingFence = DetectedActivityFence.during(DetectedActivityFence.WALKING);     //Create Fence
            onFootFence = DetectedActivityFence.during(DetectedActivityFence.ON_FOOT);
            runningFence = DetectedActivityFence.during(DetectedActivityFence.RUNNING);

            intent = new Intent(FENCE_RECEIVER_ACTION);                                     //Set up the intent and intent filter
            myFillter = new IntentFilter(FENCE_RECEIVER_ACTION);
            myPendingIntent = PendingIntent.getBroadcast(getContext(), 0, intent, 0);           //Set up the pendingIntent
            myFenceReceiver = new FenceReceiver();                                              //Set up the receiver
            getContext().registerReceiver(myFenceReceiver, myFillter);
            registerFence(WALKINGFENCE, walkingFence);                                       //register the fences
            registerFence(TILTINGFENCE, tiltingFence);
            registerFence(ONFOOTFENCE, onFootFence);
            registerFence(RUNNINGFENCE, runningFence);
    }
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
public void onWalkingClicked(View view) {
    if (mActivityType.contains(DetectedActivityFence.WALKING)) {
        mActivityType.remove(Integer.valueOf(DetectedActivityFence.WALKING));
        view.setBackgroundColor(Color.LTGRAY);
    } else {
        mActivityType.add(DetectedActivityFence.WALKING);
        view.setBackgroundColor(Color.WHITE);
    }
}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
public void onRunningClicked(View view) {
    if (mActivityType.contains(DetectedActivityFence.RUNNING)) {
        mActivityType.remove(Integer.valueOf(DetectedActivityFence.RUNNING));
        view.setBackgroundColor(Color.LTGRAY);
    } else {
        mActivityType.add(DetectedActivityFence.RUNNING);
        view.setBackgroundColor(Color.WHITE);
    }
}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
public void onDrivingClicked(View view) {
    if (mActivityType.contains(DetectedActivityFence.IN_VEHICLE)) {
        mActivityType.remove(Integer.valueOf(DetectedActivityFence.IN_VEHICLE));
        view.setBackgroundColor(Color.LTGRAY);
    } else {
        mActivityType.add(DetectedActivityFence.IN_VEHICLE);
        view.setBackgroundColor(Color.WHITE);
    }
}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
public void onBicyclingClicked(View view) {
    if (mActivityType.contains(DetectedActivityFence.ON_BICYCLE)) {
        mActivityType.remove(Integer.valueOf(DetectedActivityFence.ON_BICYCLE));
        view.setBackgroundColor(Color.LTGRAY);
    } else {
        mActivityType.add(DetectedActivityFence.ON_BICYCLE);
        view.setBackgroundColor(Color.WHITE);
    }
}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
public void onStillClicked(View view) {
    if (mActivityType.contains(DetectedActivityFence.STILL)) {
        mActivityType.remove(Integer.valueOf(DetectedActivityFence.STILL));
        view.setBackgroundColor(Color.LTGRAY);
    } else {
        mActivityType.add(DetectedActivityFence.STILL);
        view.setBackgroundColor(Color.WHITE);
    }
}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
public void onFootClicked(View view) {
    if (mActivityType.contains(DetectedActivityFence.ON_FOOT)) {
        mActivityType.remove(Integer.valueOf(DetectedActivityFence.ON_FOOT));
        view.setBackgroundColor(Color.LTGRAY);
    } else {
        mActivityType.add(DetectedActivityFence.ON_FOOT);
        view.setBackgroundColor(Color.WHITE);
    }
}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
@RequiresPermission("com.google.android.gms.permission.ACTIVITY_RECOGNITION")
@Override
AwarenessFence getAwarenessFence(Context ctx) {
    switch (mTransitionType) {
        case DURING_TYPE:
            return DetectedActivityFence.during(mActivityTypes);
        case START_TYPE:
            return DetectedActivityFence.starting(mActivityTypes);
        case STOP_TYPE:
            return DetectedActivityFence.stopping(mActivityTypes);
    }
    return null;
}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    mStore = new FenceStore(mContext, "test");
    mAct1 = StorableActivityFence.starting(DetectedActivityFence.IN_VEHICLE);
    mAct2 = StorableActivityFence.during(DetectedActivityFence.RUNNING);
    mLoc1 = StorableLocationFence.entering(2, 3, 30);
    mLoc2 = StorableLocationFence.exiting(3, 4, 40);
    mAnd = StorableFence.and(mAct1, mAct2);
    mNot = StorableFence.or(mLoc1);
    mOr = StorableFence.or(mNot, mAnd, mLoc2);
}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
@Before
@Override
public void setUp() throws Exception {
    super.setUp();
    mAct1 = StorableActivityFence.starting(DetectedActivityFence.IN_VEHICLE);
    mAct1.setPendingIntentClass("className");
    mAct2 = StorableActivityFence.during(DetectedActivityFence.RUNNING);
    mLoc1 = StorableLocationFence.entering(2, 3, 30);
    mLoc1.setId("1");
    mLoc2 = StorableLocationFence.exiting(3, 4, 40);
    mHead1 = StorableHeadphoneFence.during(HeadphoneState.PLUGGED_IN);
    mTime1 = StorableTimeFence.inFridayInterval(TimeZone.getDefault(), 20, 20000);

}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
@Test
public void testEquals() {
    StorableActivityFence fence1 = StorableActivityFence.starting(
            DetectedActivityFence.IN_VEHICLE, DetectedActivityFence.RUNNING);
    StorableActivityFence fence2 = StorableActivityFence.stopping(
            DetectedActivityFence.ON_BICYCLE, DetectedActivityFence.WALKING);
    StorableActivityFence fence3 = StorableActivityFence.stopping(
            DetectedActivityFence.ON_BICYCLE, DetectedActivityFence.WALKING);

    assertThat(fence1.equals(fence1), is(true));
    assertThat(fence2.equals(fence3), is(true));
    assertThat(fence3.equals(null), is(false));
    assertThat(fence3.equals(fence1), is(false));
}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
private void addHeadphoneOrLocationFence() {
    Intent intent = new Intent(MY_FENCE_RECEIVER_ACTION);
    PendingIntent mFencePendingIntent = PendingIntent.getBroadcast(FenceActivity.this,
            10001,
            intent,
            0);

    AwarenessFence headphoneFence = HeadphoneFence.during(HeadphoneState.PLUGGED_IN);
    AwarenessFence activityFence = DetectedActivityFence.during(DetectedActivityFence.WALKING);

    AwarenessFence orFence = AwarenessFence.or(headphoneFence, activityFence);
    Awareness.FenceApi.updateFences(
            mGoogleApiClient,
            new FenceUpdateRequest.Builder()
                    .addFence(HEADPHONE_OR_WALKING_FENCE_KEY,
                            orFence, mFencePendingIntent)
                    .build())
            .setResultCallback(new ResultCallback<Status>() {
                @Override
                public void onResult(@NonNull Status status) {
                    if (status.isSuccess()) {
                        Log.i(TAG, "Headphones OR Walking Fence was successfully registered.");
                    } else {
                        Log.e(TAG, "Headphones OR Walking Fence could not be registered: " + status);
                    }
                }
            });
}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
public String getFenceStr(StorableFence fence) {
    String str = "";
    switch (fence.getType()) {
        case ACTIVITY:
            for (@StorableActivityFence.ActivityType int act : ((StorableActivityFence) fence).getActivityTypes()) {
                if (!str.isEmpty()) {
                    str += ", ";
                }
                switch (act) {
                    case DetectedActivityFence.IN_VEHICLE:
                        str += "IN_VEHICLE";
                        break;
                    case DetectedActivityFence.ON_BICYCLE:
                        str += "ON_BICYCLE";
                        break;
                    case DetectedActivityFence.ON_FOOT:
                        str += "ON_FOOT";
                        break;
                    case DetectedActivityFence.RUNNING:
                        str += "RUNNING";
                        break;
                    case DetectedActivityFence.STILL:
                        str += "STILL";
                        break;
                    case DetectedActivityFence.WALKING:
                        str += "WALKING";
                        break;
                    case DetectedActivityFence.UNKNOWN:
                    default:
                        str += "UNKNOWN";
                        break;
                }
            }
            break;
        case LOCATION:
            StorableLocationFence locFence = (StorableLocationFence) fence;
            str += "(" + locFence.getLatitude() + ", " + locFence.getLongitude() + ") ";
            break;
        default:
            break;
    }
    return str;
}
 

import com.google.android.gms.awareness.fence.DetectedActivityFence; //导入依赖的package包/类
/**
 * Sets up {@link AwarenessFence}'s for the sample app, and registers callbacks for them
 * with a custom {@link BroadcastReceiver}
 */
private void setupFences() {
    // DetectedActivityFence will fire when it detects the user performing the specified
    // activity.  In this case it's walking.
    AwarenessFence walkingFence = DetectedActivityFence.during(DetectedActivityFence.WALKING);

    // There are lots of cases where it's handy for the device to know if headphones have been
    // plugged in or unplugged.  For instance, if a music app detected your headphones fell out
    // when you were in a library, it'd be pretty considerate of the app to pause itself before
    // the user got in trouble.
    AwarenessFence headphoneFence = HeadphoneFence.during(HeadphoneState.PLUGGED_IN);

    // Combines multiple fences into a compound fence.  While the first two fences trigger
    // individually, this fence will only trigger its callback when all of its member fences
    // hit a true state.
    AwarenessFence walkingWithHeadphones = AwarenessFence.and(walkingFence, headphoneFence);

    // We can even nest compound fences.  Using both "and" and "or" compound fences, this
    // compound fence will determine when the user has headphones in and is engaging in at least
    // one form of exercise.
    // The below breaks down to "(headphones plugged in) AND (walking OR running OR bicycling)"
    AwarenessFence exercisingWithHeadphonesFence = AwarenessFence.and(
            headphoneFence,
            AwarenessFence.or(
                    walkingFence,
                    DetectedActivityFence.during(DetectedActivityFence.RUNNING),
                    DetectedActivityFence.during(DetectedActivityFence.ON_BICYCLE)));


    // Now that we have an interesting, complex condition, register the fence to receive
    // callbacks.

    // Register the fence to receive callbacks.
    Awareness.getFenceClient(this).updateFences(new FenceUpdateRequest.Builder()
            .addFence(FENCE_KEY, exercisingWithHeadphonesFence, mPendingIntent)
            .build())
            .addOnSuccessListener(new OnSuccessListener<Void>() {
                @Override
                public void onSuccess(Void aVoid) {
                    Log.i(TAG, "Fence was successfully registered.");
                }
            })
            .addOnFailureListener(new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                    Log.e(TAG, "Fence could not be registered: " + e);
                }
            });
}