Home | History | Annotate | Download | only in am 
      1 /*
      2  * Copyright (C) 2012 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.server.am;
     18 
     19 import static com.android.server.am.ActivityManagerDebugConfig.TAG_AM;
     20 import static com.android.server.am.ActivityManagerDebugConfig.TAG_WITH_CLASS_NAME;
     21 
     22 import android.app.IStopUserCallback;
     23 import android.os.Trace;
     24 import android.os.UserHandle;
     25 import android.util.ArrayMap;
     26 import android.util.Slog;
     27 import android.util.proto.ProtoOutputStream;
     28 
     29 import com.android.internal.util.ProgressReporter;
     30 
     31 import java.io.PrintWriter;
     32 import java.util.ArrayList;
     33 
     34 public final class UserState {
     35     private static final String TAG = TAG_WITH_CLASS_NAME ? "UserState" : TAG_AM;
     36 
     37     // User is first coming up.
     38     public final static int STATE_BOOTING = 0;
     39     // User is in the locked state.
     40     public final static int STATE_RUNNING_LOCKED = 1;
     41     // User is in the unlocking state.
     42     public final static int STATE_RUNNING_UNLOCKING = 2;
     43     // User is in the running state.
     44     public final static int STATE_RUNNING_UNLOCKED = 3;
     45     // User is in the initial process of being stopped.
     46     public final static int STATE_STOPPING = 4;
     47     // User is in the final phase of stopping, sending Intent.ACTION_SHUTDOWN.
     48     public final static int STATE_SHUTDOWN = 5;
     49 
     50     public final UserHandle mHandle;
     51     public final ArrayList<IStopUserCallback> mStopCallbacks
     52             = new ArrayList<IStopUserCallback>();
     53     public final ProgressReporter mUnlockProgress;
     54 
     55     public int state = STATE_BOOTING;
     56     public int lastState = STATE_BOOTING;
     57     public boolean switching;
     58     public boolean tokenProvided;
     59 
     60     /**
     61      * The last time that a provider was reported to usage stats as being brought to important
     62      * foreground procstate.
     63      * <p><strong>Important: </strong>Only access this field when holding ActivityManagerService
     64      * lock.
     65      */
     66     final ArrayMap<String,Long> mProviderLastReportedFg = new ArrayMap<>();
     67 
     68     public UserState(UserHandle handle) {
     69         mHandle = handle;
     70         mUnlockProgress = new ProgressReporter(handle.getIdentifier());
     71     }
     72 
     73     public boolean setState(int oldState, int newState) {
     74         if (state == oldState) {
     75             setState(newState);
     76             return true;
     77         } else {
     78             Slog.w(TAG, "Expected user " + mHandle.getIdentifier() + " in state "
     79                     + stateToString(oldState) + " but was in state " + stateToString(state));
     80             return false;
     81         }
     82     }
     83 
     84     public void setState(int newState) {
     85         if (newState == state) {
     86             return;
     87         }
     88         final int userId = mHandle.getIdentifier();
     89         if (state != STATE_BOOTING) {
     90             Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER,
     91                     stateToString(state) + " " + userId, userId);
     92         }
     93         if (newState != STATE_SHUTDOWN) {
     94             Trace.asyncTraceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
     95                     stateToString(newState) + " " + userId, userId);
     96         }
     97         Slog.i(TAG, "User " + userId + " state changed from "
     98                 + stateToString(state) + " to " + stateToString(newState));
     99         EventLogTags.writeAmUserStateChanged(userId, newState);
    100         lastState = state;
    101         state = newState;
    102     }
    103 
    104     public static String stateToString(int state) {
    105         switch (state) {
    106             case STATE_BOOTING: return "BOOTING";
    107             case STATE_RUNNING_LOCKED: return "RUNNING_LOCKED";
    108             case STATE_RUNNING_UNLOCKING: return "RUNNING_UNLOCKING";
    109             case STATE_RUNNING_UNLOCKED: return "RUNNING_UNLOCKED";
    110             case STATE_STOPPING: return "STOPPING";
    111             case STATE_SHUTDOWN: return "SHUTDOWN";
    112             default: return Integer.toString(state);
    113         }
    114     }
    115 
    116     public static int stateToProtoEnum(int state) {
    117         switch (state) {
    118             case STATE_BOOTING: return UserStateProto.STATE_BOOTING;
    119             case STATE_RUNNING_LOCKED: return UserStateProto.STATE_RUNNING_LOCKED;
    120             case STATE_RUNNING_UNLOCKING: return UserStateProto.STATE_RUNNING_UNLOCKING;
    121             case STATE_RUNNING_UNLOCKED: return UserStateProto.STATE_RUNNING_UNLOCKED;
    122             case STATE_STOPPING: return UserStateProto.STATE_STOPPING;
    123             case STATE_SHUTDOWN: return UserStateProto.STATE_SHUTDOWN;
    124             default: return state;
    125         }
    126     }
    127 
    128     void dump(String prefix, PrintWriter pw) {
    129         pw.print(prefix);
    130         pw.print("state="); pw.print(stateToString(state));
    131         if (switching) pw.print(" SWITCHING");
    132         pw.println();
    133     }
    134 
    135     void writeToProto(ProtoOutputStream proto, long fieldId) {
    136         final long token = proto.start(fieldId);
    137         proto.write(UserStateProto.STATE, stateToProtoEnum(state));
    138         proto.write(UserStateProto.SWITCHING, switching);
    139         proto.end(token);
    140     }
    141 }
    142