Home | History | Annotate | Download | only in build
      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.tradefed.build;
     18 
     19 import com.android.tradefed.device.ITestDevice;
     20 
     21 import java.io.File;
     22 import java.util.Collection;
     23 import java.util.LinkedList;
     24 import java.util.Map;
     25 
     26 /**
     27  * A {@link IDeviceBuildInfo} used for over-the-air update testing. It is composed of two device
     28  * builds for {@link ITestDevice}:
     29  * <ul>
     30  * <li>a baseline build image (the build to OTA from).</li>
     31  * <li>a OTA build (a build to OTA to). Should contain necessary build attributes and associated
     32  * OTA package.</li>
     33  * </ul>
     34  * <var>this</var> contains the baseline build, and {@link #getOtaBuild()} returns the OTA
     35  * build.
     36  */
     37 public class OtaDeviceBuildInfo implements IDeviceBuildInfo {
     38 
     39     protected IDeviceBuildInfo mOtaBuild;
     40     protected IDeviceBuildInfo mBaselineBuild;
     41     protected boolean mReportTargetBuild = false;
     42 
     43     public void setOtaBuild(IDeviceBuildInfo otaBuild) {
     44         mOtaBuild = otaBuild;
     45     }
     46 
     47     public void setBaselineBuild(IDeviceBuildInfo baselineBuild) {
     48         mBaselineBuild = baselineBuild;
     49     }
     50 
     51     public IDeviceBuildInfo getOtaBuild() {
     52         return mOtaBuild;
     53     }
     54 
     55     public IDeviceBuildInfo getBaselineBuild() {
     56         return mBaselineBuild;
     57     }
     58 
     59     /**
     60      * {@inheritDoc}
     61      */
     62     @Override
     63     public String getBuildId() {
     64         return getReportedBuild().getBuildId();
     65     }
     66 
     67     /**
     68      * {@inheritDoc}
     69      */
     70     @Override
     71     public void setBuildId(String buildId) {
     72         mBaselineBuild.setBuildId(buildId);
     73     }
     74 
     75     /**
     76      * {@inheritDoc}
     77      */
     78     @Override
     79     public String getTestTag() {
     80         return mBaselineBuild.getTestTag();
     81     }
     82 
     83     /**
     84      * {@inheritDoc}
     85      */
     86     @Override
     87     public void setTestTag(String testTag) {
     88         mBaselineBuild.setTestTag(testTag);
     89     }
     90 
     91     /**
     92      * {@inheritDoc}
     93      */
     94     @Override
     95     public String getBuildTargetName() {
     96         return getReportedBuild().getBuildTargetName();
     97     }
     98 
     99     /**
    100      * {@inheritDoc}
    101      */
    102     @Override
    103     public String getBuildFlavor() {
    104         return getReportedBuild().getBuildFlavor();
    105     }
    106 
    107     /**
    108      * {@inheritDoc}
    109      */
    110     @Override
    111     public String getDeviceSerial() {
    112         return mBaselineBuild.getDeviceSerial();
    113     }
    114 
    115     /**
    116      * {@inheritDoc}
    117      */
    118     @Override
    119     public void setBuildFlavor(String buildFlavor) {
    120         mBaselineBuild.setBuildFlavor(buildFlavor);
    121     }
    122 
    123     /**
    124      * {@inheritDoc}
    125      */
    126     @Override
    127     public String getBuildBranch() {
    128         return getReportedBuild().getBuildBranch();
    129     }
    130 
    131     /**
    132      * {@inheritDoc}
    133      */
    134     @Override
    135     public void setBuildBranch(String branch) {
    136         mBaselineBuild.setBuildBranch(branch);
    137     }
    138 
    139     /**
    140      * {@inheritDoc}
    141      */
    142     @Override
    143     public void setDeviceSerial(String serial) {
    144         mBaselineBuild.setDeviceSerial(serial);
    145     }
    146 
    147     /**
    148      * {@inheritDoc}
    149      */
    150     @Override
    151     public Map<String, String> getBuildAttributes() {
    152         return getReportedBuild().getBuildAttributes();
    153     }
    154 
    155     /**
    156      * {@inheritDoc}
    157      */
    158     @Override
    159     public void addBuildAttribute(String attributeName, String attributeValue) {
    160         mBaselineBuild.addBuildAttribute(attributeName, attributeValue);
    161     }
    162 
    163     /**
    164      * {@inheritDoc}
    165      */
    166     @Override
    167     public File getFile(String name) {
    168         return mBaselineBuild.getFile(name);
    169     }
    170 
    171     /**
    172      * {@inheritDoc}
    173      */
    174     @Override
    175     public String getVersion(String name) {
    176         return mBaselineBuild.getVersion(name);
    177     }
    178 
    179     /**
    180      * {@inheritDoc}
    181      */
    182     @Override
    183     public void setFile(String name, File file, String version) {
    184         mBaselineBuild.setFile(name, file, version);
    185     }
    186 
    187     /**
    188      * {@inheritDoc}
    189      */
    190     @Override
    191     public String getDeviceBuildId() {
    192         return mBaselineBuild.getDeviceBuildId();
    193     }
    194 
    195     /**
    196      * {@inheritDoc}
    197      */
    198     @Override
    199     public String getDeviceBuildFlavor() {
    200         return mBaselineBuild.getDeviceBuildFlavor();
    201     }
    202 
    203     /**
    204      * {@inheritDoc}
    205      */
    206     @Override
    207     public File getDeviceImageFile() {
    208         return mBaselineBuild.getDeviceImageFile();
    209     }
    210 
    211     /**
    212      * {@inheritDoc}
    213      */
    214     @Override
    215     public String getDeviceImageVersion() {
    216         return mBaselineBuild.getDeviceImageVersion();
    217     }
    218 
    219     /**
    220      * {@inheritDoc}
    221      */
    222     @Override
    223     public void setDeviceImageFile(File deviceImageFile, String version) {
    224         mBaselineBuild.setDeviceImageFile(deviceImageFile, version);
    225     }
    226 
    227     /**
    228      * {@inheritDoc}
    229      */
    230     @Override
    231     public File getUserDataImageFile() {
    232         return mBaselineBuild.getUserDataImageFile();
    233     }
    234 
    235     /**
    236      * {@inheritDoc}
    237      */
    238     @Override
    239     public String getUserDataImageVersion() {
    240         return mBaselineBuild.getUserDataImageVersion();
    241     }
    242 
    243     /**
    244      * {@inheritDoc}
    245      */
    246     @Override
    247     public void setUserDataImageFile(File userDataFile, String version) {
    248         mBaselineBuild.setUserDataImageFile(userDataFile, version);
    249     }
    250 
    251     /**
    252      * {@inheritDoc}
    253      */
    254     @Override
    255     public File getTestsDir() {
    256         return mBaselineBuild.getTestsDir();
    257     }
    258 
    259     /**
    260      * {@inheritDoc}
    261      */
    262     @Override
    263     public String getTestsDirVersion() {
    264         return mBaselineBuild.getTestsDirVersion();
    265     }
    266 
    267     /**
    268      * {@inheritDoc}
    269      */
    270     @Override
    271     public void setTestsDir(File testsZipFile, String version) {
    272         mBaselineBuild.setTestsDir(testsZipFile, version);
    273     }
    274 
    275     /**
    276      * {@inheritDoc}
    277      */
    278     @Override
    279     public File getBasebandImageFile() {
    280         return mBaselineBuild.getBasebandImageFile();
    281     }
    282 
    283     /**
    284      * {@inheritDoc}
    285      */
    286     @Override
    287     public String getBasebandVersion() {
    288         return mBaselineBuild.getBasebandVersion();
    289     }
    290 
    291     /**
    292      * {@inheritDoc}
    293      */
    294     @Override
    295     public void setBasebandImage(File basebandFile, String version) {
    296         mBaselineBuild.setBasebandImage(basebandFile, version);
    297     }
    298 
    299     /**
    300      * {@inheritDoc}
    301      */
    302     @Override
    303     public File getBootloaderImageFile() {
    304         return mBaselineBuild.getBootloaderImageFile();
    305     }
    306 
    307     /**
    308      * {@inheritDoc}
    309      */
    310     @Override
    311     public String getBootloaderVersion() {
    312         return mBaselineBuild.getBootloaderVersion();
    313     }
    314 
    315     /**
    316      * {@inheritDoc}
    317      */
    318     @Override
    319     public void setBootloaderImageFile(File bootloaderImgFile, String version) {
    320         mBaselineBuild.setBootloaderImageFile(bootloaderImgFile, version);
    321     }
    322 
    323     /**
    324      * {@inheritDoc}
    325      */
    326     @Override
    327     public File getOtaPackageFile() {
    328         return mBaselineBuild.getOtaPackageFile();
    329     }
    330 
    331     /**
    332      * {@inheritDoc}
    333      */
    334     @Override
    335     public String getOtaPackageVersion() {
    336         return mBaselineBuild.getOtaPackageVersion();
    337     }
    338 
    339     /**
    340      * {@inheritDoc}
    341      */
    342     @Override
    343     public void setOtaPackageFile(File otaFile, String version) {
    344         mBaselineBuild.setOtaPackageFile(otaFile, version);
    345     }
    346 
    347     /**
    348      * {@inheritDoc}
    349      */
    350     @Override
    351     public File getMkbootimgFile() {
    352         return mBaselineBuild.getMkbootimgFile();
    353     }
    354 
    355     /**
    356      * {@inheritDoc}
    357      */
    358     @Override
    359     public String getMkbootimgVersion() {
    360         return mBaselineBuild.getMkbootimgVersion();
    361     }
    362 
    363     /**
    364      * {@inheritDoc}
    365      */
    366     @Override
    367     public void setMkbootimgFile(File mkbootimg, String version) {
    368         mBaselineBuild.setMkbootimgFile(mkbootimg, version);
    369     }
    370 
    371     /**
    372      * {@inheritDoc}
    373      */
    374     @Override
    375     public File getRamdiskFile() {
    376         return mBaselineBuild.getRamdiskFile();
    377     }
    378 
    379     /**
    380      * {@inheritDoc}
    381      */
    382     @Override
    383     public String getRamdiskVersion() {
    384         return mBaselineBuild.getRamdiskVersion();
    385     }
    386 
    387     /**
    388      * {@inheritDoc}
    389      */
    390     @Override
    391     public void setRamdiskFile(File ramdisk, String version) {
    392         mBaselineBuild.setRamdiskFile(ramdisk, version);
    393     }
    394 
    395     /**
    396      * {@inheritDoc}
    397      */
    398     @Override
    399     public void cleanUp() {
    400         mBaselineBuild.cleanUp();
    401         mOtaBuild.cleanUp();
    402     }
    403 
    404     /**
    405      * {@inheritDoc}
    406      */
    407     @Override
    408     public IBuildInfo clone() {
    409         OtaDeviceBuildInfo clone = new OtaDeviceBuildInfo();
    410         if (mBaselineBuild != null) {
    411             clone.setBaselineBuild((IDeviceBuildInfo)mBaselineBuild.clone());
    412         }
    413         if (mOtaBuild != null) {
    414             clone.setOtaBuild((IDeviceBuildInfo)mOtaBuild.clone());
    415         }
    416         return clone;
    417     }
    418 
    419     /**
    420      * {@inheritDoc}
    421      */
    422     @Override
    423     public Collection<VersionedFile> getFiles() {
    424         Collection<VersionedFile> combinedFiles = new LinkedList<VersionedFile>();
    425         combinedFiles.addAll(mBaselineBuild.getFiles());
    426         combinedFiles.addAll(mOtaBuild.getFiles());
    427         return combinedFiles;
    428     }
    429 
    430     public void setReportTargetBuild(boolean downgrade) {
    431         mReportTargetBuild = downgrade;
    432     }
    433 
    434     protected IDeviceBuildInfo getReportedBuild() {
    435         return (mReportTargetBuild ? mOtaBuild : mBaselineBuild);
    436     }
    437 }
    438